# frozen_string_literal: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

            # 管理者専用のActionCableチャンネル
          
        
      
        

          

            

            
              
            

            # CSVインポート進捗や在庫アラートなどのリアルタイム通知を担当
          
        
      
        

          

            

            
              
            

            class AdminChannel < ApplicationCable::Channel
          
        
      
        

          

            

            
              
            

              # ============================================
          
        
      
        

          

            

            
              
            

              # チャンネル接続処理
          
        
      
        

          

            

            
              
            

              # ============================================
          
        
      
        

          

            

            
              
            

              def subscribed
          
        
      
        

          

            

            
              
            

                # 認証チェック
          
        
      
        

          

            

            
              
            

                reject unless current_admin
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                # 管理者専用のストリームに接続
          
        
      
        

          

            

            
              
            

                stream_for current_admin
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                Rails.logger.info "Admin #{current_admin.id} subscribed to AdminChannel"
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                # 接続完了通知
          
        
      
        

          

            

            
              
            

                transmit({
          
        
      
        

          

            

            
              
            

                  type: "connection_established",
          
        
      
        

          

            

            
              
            

                  admin_id: current_admin.id,
          
        
      
        

          

            

            
              
            

                  timestamp: Time.current.iso8601
          
        
      
        

          

            

            
              
            

                })
          
        
      
        

          

            

            
              
            

              end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

              def unsubscribed
          
        
      
        

          

            

            
              
            

                Rails.logger.info "Admin #{current_admin&.id} unsubscribed from AdminChannel"
          
        
      
        

          

            

            
              
            

              end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

              # ============================================
          
        
      
        

          

            

            
              
            

              # CSV インポート進捗追跡の開始
          
        
      
        

          

            

            
              
            

              # ============================================
          
        
      
        

          

            

            
              
            

              def track_csv_import(data)
          
        
      
        

          

            

            
              
            

                job_id = data["job_id"]
          
        
      
        

          

            

            
              
            

                return reject_action("job_id required") unless job_id.present?
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                # Redis からジョブ状況を取得
          
        
      
        

          

            

            
              
            

                redis = get_redis_connection
          
        
      
        

          

            

            
              
            

                return reject_action("Redis unavailable") unless redis
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                status_key = "csv_import:#{job_id}"
          
        
      
        

          

            

            
              
            

                job_data = redis.hgetall(status_key)
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                if job_data.empty?
          
        
      
        

          

            

            
              
            

                  transmit({
          
        
      
        

          

            

            
              
            

                    type: "csv_import_not_found",
          
        
      
        

          

            

            
              
            

                    job_id: job_id,
          
        
      
        

          

            

            
              
            

                    message: "指定されたインポートジョブが見つかりません",
          
        
      
        

          

            

            
              
            

                    timestamp: Time.current.iso8601
          
        
      
        

          

            

            
              
            

                  })
          
        
      
        

          

            

            
              
            

                  return
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                # 現在の進捗状況を送信
          
        
      
        

          

            

            
              
            

                transmit({
          
        
      
        

          

            

            
              
            

                  type: "csv_import_status",
          
        
      
        

          

            

            
              
            

                  job_id: job_id,
          
        
      
        

          

            

            
              
            

                  status: job_data["status"],
          
        
      
        

          

            

            
              
            

                  progress: job_data["progress"]&.to_i || 0,
          
        
      
        

          

            

            
              
            

                  started_at: job_data["started_at"],
          
        
      
        

          

            

            
              
            

                  admin_id: job_data["admin_id"],
          
        
      
        

          

            

            
              
            

                  file_path: job_data["file_path"],
          
        
      
        

          

            

            
              
            

                  timestamp: Time.current.iso8601
          
        
      
        

          

            

            
              
            

                })
          
        
      
        

          

            

            
              
            

              end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

              # ============================================
          
        
      
        

          

            

            
              
            

              # 在庫アラート通知の購読
          
        
      
        

          

            

            
              
            

              # ============================================
          
        
      
        

          

            

            
              
            

              def subscribe_stock_alerts(data)
          
        
      
        

          

            

            
              
            

                # 在庫アラート用のストリームに追加接続
          
        
      
        

          

            

            
              
            

                stream_from "stock_alerts"
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                transmit({
          
        
      
        

          

            

            
              
            

                  type: "stock_alerts_subscribed",
          
        
      
        

          

            

            
              
            

                  message: "在庫アラート通知を開始しました",
          
        
      
        

          

            

            
              
            

                  timestamp: Time.current.iso8601
          
        
      
        

          

            

            
              
            

                })
          
        
      
        

          

            

            
              
            

              end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

              # ============================================
          
        
      
        

          

            

            
              
            

              # システム通知の購読
          
        
      
        

          

            

            
              
            

              # ============================================
          
        
      
        

          

            

            
              
            

              def subscribe_system_notifications(data)
          
        
      
        

          

            

            
              
            

                # システム通知用のストリームに追加接続
          
        
      
        

          

            

            
              
            

                stream_from "system_notifications"
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                transmit({
          
        
      
        

          

            

            
              
            

                  type: "system_notifications_subscribed",
          
        
      
        

          

            

            
              
            

                  message: "システム通知を開始しました",
          
        
      
        

          

            

            
              
            

                  timestamp: Time.current.iso8601
          
        
      
        

          

            

            
              
            

                })
          
        
      
        

          

            

            
              
            

              end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

              # ============================================
          
        
      
        

          

            

            
              
            

              # エラーハンドリング
          
        
      
        

          

            

            
              
            

              # ============================================
          
        
      
        

          

            

            
              
            

              private
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

              def current_admin
          
        
      
        

          

            

            
              
            

                # Deviseの認証情報から管理者を取得
          
        
      
        

          

            

            
              
            

                @current_admin ||= env["warden"]&.user(:admin)
          
        
      
        

          

            

            
              
            

              end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

              def reject_action(reason)
          
        
      
        

          

            

            
              
            

                transmit({
          
        
      
        

          

            

            
              
            

                  type: "action_rejected",
          
        
      
        

          

            

            
              
            

                  reason: reason,
          
        
      
        

          

            

            
              
            

                  timestamp: Time.current.iso8601
          
        
      
        

          

            

            
              
            

                })
          
        
      
        

          

            

            
              
            

              end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

              def get_redis_connection
          
        
      
        

          

            

            
              
            

                # ImportInventoriesJobと同じRedis接続ロジックを使用
          
        
      
        

          

            

            
              
            

                if Rails.env.test?
          
        
      
        

          

            

            
              
            

                  return nil unless defined?(Redis)
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                  begin
          
        
      
        

          

            

            
              
            

                    redis = Redis.current
          
        
      
        

          

            

            
              
            

                    redis.ping
          
        
      
        

          

            

            
              
            

                    return redis
          
        
      
        

          

            

            
              
            

                  rescue => e
          
        
      
        

          

            

            
              
            

                    Rails.logger.warn "Redis not available in test environment: #{e.message}"
          
        
      
        

          

            

            
              
            

                    return nil
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                begin
          
        
      
        

          

            

            
              
            

                  if defined?(Sidekiq) && Sidekiq.redis_pool
          
        
      
        

          

            

            
              
            

                    Sidekiq.redis { |conn| return conn }
          
        
      
        

          

            

            
              
            

                  else
          
        
      
        

          

            

            
              
            

                    Redis.current
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

                rescue => e
          
        
      
        

          

            

            
              
            

                  Rails.logger.warn "Redis connection failed: #{e.message}"
          
        
      
        

          

            

            
              
            

                  nil
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

              end
          
        
      
        

          

            

            
              
            

            end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

            # ============================================
          
        
      
        

          

            

            
              
            

            # TODO: 将来の拡張機能（優先度：中）
          
        
      
        

          

            

            
              
            

            # ============================================
          
        
      
        

          

            

            
              
            

            # 1. マルチテナント対応
          
        
      
        

          

            

            
              
            

            #    - 組織単位での通知チャンネル分離
          
        
      
        

          

            

            
              
            

            #    - 権限ベースの通知フィルタリング
          
        
      
        

          

            

            
              
            

            #
          
        
      
        

          

            

            
              
            

            # 2. 通知設定のカスタマイズ
          
        
      
        

          

            

            
              
            

            #    - 個別管理者の通知設定保存
          
        
      
        

          

            

            
              
            

            #    - 通知頻度・タイミングの調整
          
        
      
        

          

            

            
              
            

            #
          
        
      
        

          

            

            
              
            

            # 3. パフォーマンス最適化
          
        
      
        

          

            

            
              
            

            #    - バッチ通知による負荷軽減
          
        
      
        

          

            

            
              
            

            #    - Redis Pub/Sub の効率的活用
          
        
      
        

          

            

            
              
            

            #
          
        
      
        

          

            

            
              
            

            # 4. 監視・分析機能
          
        
      
        

          

            

            
              
            

            #    - 通知配信ログの記録
          
        
      
        

          

            

            
              
            

            #    - リアルタイム接続状況の監視
          
        
      
        

          

            

            
              
            

            #    - 通知効果の分析・改善提案
          
        
      
    
  

    

      
        

          

            

            
              
            

            module ApplicationCable
          
        
      
        

          

            

            
              
            

              class Channel < ActionCable::Channel::Base
          
        
      
        

          

            

            
              
            

              end
          
        
      
        

          

            

            
              
            

            end
          
        
      
    
  

    

      
        

          

            

            
              
            

            # frozen_string_literal: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

            module ApplicationCable
          
        
      
        

          

            

            
              
            

              class Connection < ActionCable::Connection::Base
          
        
      
        

          

            

            
              
            

                identified_by :current_admin
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                def connect
          
        
      
        

          

            

            
              
            

                  self.current_admin = find_verified_admin
          
        
      
        

          

            

            
              
            

                  Rails.logger.info "ActionCable connection established for Admin #{current_admin&.id}"
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                private
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                def find_verified_admin
          
        
      
        

          

            

            
              
            

                  # Deviseのセッション情報から管理者を取得
          
        
      
        

          

            

            
              
            

                  admin_id = cookies.signed[:admin_id] ||
          
        
      
        

          

            

            
              
            

                             request.session[:admin_id] ||
          
        
      
        

          

            

            
              
            

                             extract_admin_from_warden
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                  if admin_id && (admin = Admin.find_by(id: admin_id))
          
        
      
        

          

            

            
              
            

                    Rails.logger.debug "Admin #{admin.id} authenticated via ActionCable"
          
        
      
        

          

            

            
              
            

                    admin
          
        
      
        

          

            

            
              
            

                  else
          
        
      
        

          

            

            
              
            

                    Rails.logger.warn "ActionCable connection rejected: Admin not authenticated"
          
        
      
        

          

            

            
              
            

                    reject_unauthorized_connection
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                def extract_admin_from_warden
          
        
      
        

          

            

            
              
            

                  # Wardenから直接認証情報を取得
          
        
      
        

          

            

            
              
            

                  env = request.env
          
        
      
        

          

            

            
              
            

                  warden = env["warden"]
          
        
      
        

          

            

            
              
            

                  return nil unless warden
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                  admin = warden.user(:admin)
          
        
      
        

          

            

            
              
            

                  admin&.id
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

              end
          
        
      
        

          

            

            
              
            

            end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

            # ============================================
          
        
      
        

          

            

            
              
            

            # TODO: ActionCable認証の強化（優先度：高）
          
        
      
        

          

            

            
              
            

            # REF: doc/remaining_tasks.md - セキュリティ強化
          
        
      
        

          

            

            
              
            

            # ============================================
          
        
      
        

          

            

            
              
            

            # 1. JWTトークンベース認証の実装
          
        
      
        

          

            

            
              
            

            #    - セッションベースからトークンベースへの移行
          
        
      
        

          

            

            
              
            

            #    - より安全な認証情報の伝達機能
          
        
      
        

          

            

            
              
            

            #    - トークンの有効期限管理とリフレッシュ機能
          
        
      
        

          

            

            
              
            

            #    - HS256/RS256署名によるトークン完全性検証
          
        
      
        

          

            

            
              
            

            #
          
        
      
        

          

            

            
              
            

            # 実装例：
          
        
      
        

          

            

            
              
            

            # def find_verified_admin_jwt
          
        
      
        

          

            

            
              
            

            #   token = request.params[:token] ||
          
        
      
        

          

            

            
              
            

            #           cookies.signed[:auth_token] ||
          
        
      
        

          

            

            
              
            

            #           extract_token_from_header
          
        
      
        

          

            

            
              
            

            #
          
        
      
        

          

            

            
              
            

            #   decoded_token = JWT.decode(token, Rails.application.secret_key_base)
          
        
      
        

          

            

            
              
            

            #   payload = decoded_token.first
          
        
      
        

          

            

            
              
            

            #
          
        
      
        

          

            

            
              
            

            #   admin_id = payload['admin_id']
          
        
      
        

          

            

            
              
            

            #   exp = payload['exp']
          
        
      
        

          

            

            
              
            

            #
          
        
      
        

          

            

            
              
            

            #   return nil if Time.current.to_i > exp
          
        
      
        

          

            

            
              
            

            #
          
        
      
        

          

            

            
              
            

            #   Admin.find_by(id: admin_id)
          
        
      
        

          

            

            
              
            

            # rescue JWT::DecodeError, JWT::ExpiredSignature
          
        
      
        

          

            

            
              
            

            #   nil
          
        
      
        

          

            

            
              
            

            # end
          
        
      
        

          

            

            
              
            

            #
          
        
      
        

          

            

            
              
            

            # 2. IP制限・ジオブロッキング（優先度：高）
          
        
      
        

          

            

            
              
            

            #    - 許可されたIPアドレスからのみ接続を許可
          
        
      
        

          

            

            
              
            

            #    - 地理的な制限の実装
          
        
      
        

          

            

            
              
            

            #    - VPN・プロキシ検出機能
          
        
      
        

          

            

            
              
            

            #
          
        
      
        

          

            

            
              
            

            # def verify_ip_restriction
          
        
      
        

          

            

            
              
            

            #   client_ip = request.remote_ip
          
        
      
        

          

            

            
              
            

            #   allowed_ips = Rails.application.config.actioncable_allowed_ips
          
        
      
        

          

            

            
              
            

            #
          
        
      
        

          

            

            
              
            

            #   return true if allowed_ips.blank?
          
        
      
        

          

            

            
              
            

            #
          
        
      
        

          

            

            
              
            

            #   allowed_ips.any? { |ip| IPAddr.new(ip).include?(client_ip) }
          
        
      
        

          

            

            
              
            

            # end
          
        
      
        

          

            

            
              
            

            #
          
        
      
        

          

            

            
              
            

            # 3. レート制限・DDoS対策（優先度：高）
          
        
      
        

          

            

            
              
            

            #    - 接続頻度の制限
          
        
      
        

          

            

            
              
            

            #    - Redis + Sliding Window による制限実装
          
        
      
        

          

            

            
              
            

            #    - 不正アクセス試行の記録と自動ブロック
          
        
      
        

          

            

            
              
            

            #
          
        
      
        

          

            

            
              
            

            # def check_rate_limit
          
        
      
        

          

            

            
              
            

            #   redis = Redis.current
          
        
      
        

          

            

            
              
            

            #   key = "actioncable_rate_limit:#{request.remote_ip}"
          
        
      
        

          

            

            
              
            

            #   current_count = redis.incr(key)
          
        
      
        

          

            

            
              
            

            #   redis.expire(key, 60) if current_count == 1
          
        
      
        

          

            

            
              
            

            #
          
        
      
        

          

            

            
              
            

            #   if current_count > 10 # 1分間に10回まで
          
        
      
        

          

            

            
              
            

            #     Rails.logger.warn "Rate limit exceeded for IP: #{request.remote_ip}"
          
        
      
        

          

            

            
              
            

            #     false
          
        
      
        

          

            

            
              
            

            #   else
          
        
      
        

          

            

            
              
            

            #     true
          
        
      
        

          

            

            
              
            

            #   end
          
        
      
        

          

            

            
              
            

            # end
          
        
      
        

          

            

            
              
            

            #
          
        
      
        

          

            

            
              
            

            # 4. 監査ログ強化（優先度：高）
          
        
      
        

          

            

            
              
            

            #    - 接続・切断の詳細ログ
          
        
      
        

          

            

            
              
            

            #    - 不正アクセス試行の記録
          
        
      
        

          

            

            
              
            

            #    - セキュリティイベントの構造化ログ出力
          
        
      
        

          

            

            
              
            

            #
          
        
      
        

          

            

            
              
            

            # def log_security_event(event_type, details = {})
          
        
      
        

          

            

            
              
            

            #   SecurityAuditLog.create!(
          
        
      
        

          

            

            
              
            

            #     event_type: event_type,
          
        
      
        

          

            

            
              
            

            #     ip_address: request.remote_ip,
          
        
      
        

          

            

            
              
            

            #     user_agent: request.user_agent,
          
        
      
        

          

            

            
              
            

            #     admin_id: current_admin&.id,
          
        
      
        

          

            

            
              
            

            #     details: details,
          
        
      
        

          

            

            
              
            

            #     severity: determine_severity(event_type)
          
        
      
        

          

            

            
              
            

            #   )
          
        
      
        

          

            

            
              
            

            # end
          
        
      
    
  

    

      
        

          

            

            
              
            

            # frozen_string_literal: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

            # CSV Import Progress Channel
          
        
      
        

          

            

            
              
            

            # ============================================
          
        
      
        

          

            

            
              
            

            # CLAUDE.md準拠: リアルタイム進捗表示機能
          
        
      
        

          

            

            
              
            

            # 優先度: 中（UX向上）
          
        
      
        

          

            

            
              
            

            # ============================================
          
        
      
        

          

            

            
              
            

            class ImportProgressChannel < ApplicationCable::Channel
          
        
      
        

          

            

            
              
            

              # チャンネル登録
          
        
      
        

          

            

            
              
            

              def subscribed
          
        
      
        

          

            

            
              
            

                # 認証チェック
          
        
      
        

          

            

            
              
            

                unless current_admin
          
        
      
        

          

            

            
              
            

                  reject
          
        
      
        

          

            

            
              
            

                  return
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                # CSVインポート用のストリーム名生成
          
        
      
        

          

            

            
              
            

                stream_name = "import_progress_#{current_admin.id}"
          
        
      
        

          

            

            
              
            

                stream_from stream_name
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                Rails.logger.info "📡 Import progress channel subscribed: #{stream_name}"
          
        
      
        

          

            

            
              
            

              end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

              # チャンネル登録解除
          
        
      
        

          

            

            
              
            

              def unsubscribed
          
        
      
        

          

            

            
              
            

                Rails.logger.info "📡 Import progress channel unsubscribed"
          
        
      
        

          

            

            
              
            

              end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

              # 進捗更新受信
          
        
      
        

          

            

            
              
            

              def receive(data)
          
        
      
        

          

            

            
              
            

                # セキュリティ: クライアントからの受信は基本的に無視
          
        
      
        

          

            

            
              
            

                # サーバー側からのブロードキャストのみ処理
          
        
      
        

          

            

            
              
            

                Rails.logger.debug "📨 Import progress channel received: #{data}"
          
        
      
        

          

            

            
              
            

              end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

              # プログレス通知メソッド（クラスメソッド）
          
        
      
        

          

            

            
              
            

              def self.broadcast_progress(admin_id, progress_data)
          
        
      
        

          

            

            
              
            

                # 進捗データの検証
          
        
      
        

          

            

            
              
            

                validated_data = validate_progress_data(progress_data)
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                stream_name = "import_progress_#{admin_id}"
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                Rails.logger.info "📤 Broadcasting import progress to #{stream_name}: #{validated_data[:status]}"
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                # ActionCableでブロードキャスト
          
        
      
        

          

            

            
              
            

                ActionCable.server.broadcast(stream_name, validated_data)
          
        
      
        

          

            

            
              
            

              end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

              # エラー通知メソッド
          
        
      
        

          

            

            
              
            

              def self.broadcast_error(admin_id, error_message, details = {})
          
        
      
        

          

            

            
              
            

                error_data = {
          
        
      
        

          

            

            
              
            

                  status: "error",
          
        
      
        

          

            

            
              
            

                  message: error_message.to_s.truncate(500), # セキュリティ: 長大なエラーメッセージを制限
          
        
      
        

          

            

            
              
            

                  details: details.slice(:line_number, :csv_row, :error_type), # セキュリティ: 必要な情報のみ
          
        
      
        

          

            

            
              
            

                  timestamp: Time.current.iso8601
          
        
      
        

          

            

            
              
            

                }
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                broadcast_progress(admin_id, error_data)
          
        
      
        

          

            

            
              
            

              end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

              # 完了通知メソッド
          
        
      
        

          

            

            
              
            

              def self.broadcast_completion(admin_id, result_data)
          
        
      
        

          

            

            
              
            

                completion_data = {
          
        
      
        

          

            

            
              
            

                  status: "completed",
          
        
      
        

          

            

            
              
            

                  message: "CSVインポートが完了しました",
          
        
      
        

          

            

            
              
            

                  result: result_data.slice(:processed, :successful, :failed, :errors), # セキュリティ: 必要な情報のみ
          
        
      
        

          

            

            
              
            

                  timestamp: Time.current.iso8601
          
        
      
        

          

            

            
              
            

                }
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                broadcast_progress(admin_id, completion_data)
          
        
      
        

          

            

            
              
            

              end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

              private
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

              # 進捗データのバリデーション（セキュリティ強化）
          
        
      
        

          

            

            
              
            

              def self.validate_progress_data(data)
          
        
      
        

          

            

            
              
            

                # 基本構造の確認
          
        
      
        

          

            

            
              
            

                validated = {
          
        
      
        

          

            

            
              
            

                  status: sanitize_status(data[:status]),
          
        
      
        

          

            

            
              
            

                  message: sanitize_message(data[:message]),
          
        
      
        

          

            

            
              
            

                  timestamp: Time.current.iso8601
          
        
      
        

          

            

            
              
            

                }
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                # 進捗情報の追加（statusがprogressの場合）
          
        
      
        

          

            

            
              
            

                if data[:status] == "progress"
          
        
      
        

          

            

            
              
            

                  validated.merge!({
          
        
      
        

          

            

            
              
            

                    progress: validate_progress_percentage(data[:progress]),
          
        
      
        

          

            

            
              
            

                    processed: validate_count(data[:processed]),
          
        
      
        

          

            

            
              
            

                    total: validate_count(data[:total]),
          
        
      
        

          

            

            
              
            

                    current_item: sanitize_message(data[:current_item])
          
        
      
        

          

            

            
              
            

                  })
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                # エラー情報の追加（statusがerrorの場合）
          
        
      
        

          

            

            
              
            

                if data[:status] == "error"
          
        
      
        

          

            

            
              
            

                  validated.merge!({
          
        
      
        

          

            

            
              
            

                    error_type: sanitize_error_type(data[:error_type]),
          
        
      
        

          

            

            
              
            

                    line_number: validate_count(data[:line_number])
          
        
      
        

          

            

            
              
            

                  })
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                # 結果情報の追加（statusがcompletedの場合）
          
        
      
        

          

            

            
              
            

                if data[:status] == "completed"
          
        
      
        

          

            

            
              
            

                  validated.merge!({
          
        
      
        

          

            

            
              
            

                    result: {
          
        
      
        

          

            

            
              
            

                      processed: validate_count(data.dig(:result, :processed)),
          
        
      
        

          

            

            
              
            

                      successful: validate_count(data.dig(:result, :successful)),
          
        
      
        

          

            

            
              
            

                      failed: validate_count(data.dig(:result, :failed))
          
        
      
        

          

            

            
              
            

                    }
          
        
      
        

          

            

            
              
            

                  })
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                validated
          
        
      
        

          

            

            
              
            

              end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

              # ステータスのサニタイゼーション
          
        
      
        

          

            

            
              
            

              def self.sanitize_status(status)
          
        
      
        

          

            

            
              
            

                allowed_statuses = %w[pending progress error completed cancelled]
          
        
      
        

          

            

            
              
            

                status.to_s.downcase.in?(allowed_statuses) ? status.to_s.downcase : "unknown"
          
        
      
        

          

            

            
              
            

              end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

              # メッセージのサニタイゼーション
          
        
      
        

          

            

            
              
            

              def self.sanitize_message(message)
          
        
      
        

          

            

            
              
            

                return "" if message.blank?
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                # HTMLタグ除去・長さ制限
          
        
      
        

          

            

            
              
            

                ActionView::Base.full_sanitizer.sanitize(message.to_s).truncate(200)
          
        
      
        

          

            

            
              
            

              end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

              # 進捗パーセンテージのバリデーション
          
        
      
        

          

            

            
              
            

              def self.validate_progress_percentage(progress)
          
        
      
        

          

            

            
              
            

                percentage = progress.to_f
          
        
      
        

          

            

            
              
            

                [ [ percentage, 0 ].max, 100 ].min # 0-100の範囲に制限
          
        
      
        

          

            

            
              
            

              end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

              # カウント値のバリデーション
          
        
      
        

          

            

            
              
            

              def self.validate_count(count)
          
        
      
        

          

            

            
              
            

                [ count.to_i, 0 ].max # 負数は0に修正
          
        
      
        

          

            

            
              
            

              end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

              # エラータイプのサニタイゼーション
          
        
      
        

          

            

            
              
            

              def self.sanitize_error_type(error_type)
          
        
      
        

          

            

            
              
            

                allowed_types = %w[validation_error file_error processing_error system_error]
          
        
      
        

          

            

            
              
            

                error_type.to_s.downcase.in?(allowed_types) ? error_type.to_s.downcase : "unknown_error"
          
        
      
        

          

            

            
              
            

              end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

              # 管理者認証の確認
          
        
      
        

          

            

            
              
            

              def current_admin
          
        
      
        

          

            

            
              
            

                # ApplicationCable::Connectionで設定されるcurrent_adminを使用
          
        
      
        

          

            

            
              
            

                connection.current_admin
          
        
      
        

          

            

            
              
            

              end
          
        
      
        

          

            

            
              
            

            end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

            # ============================================
          
        
      
        

          

            

            
              
            

            # TODO: 🟡 Phase 6（推奨）- 高度な進捗機能実装
          
        
      
        

          

            

            
              
            

            # ============================================
          
        
      
        

          

            

            
              
            

            # 優先度: 中（UX改善）
          
        
      
        

          

            

            
              
            

            #
          
        
      
        

          

            

            
              
            

            # 【計画中の拡張機能】
          
        
      
        

          

            

            
              
            

            # 1. 📊 詳細進捗情報
          
        
      
        

          

            

            
              
            

            #    - 処理速度（行/秒）の表示
          
        
      
        

          

            

            
              
            

            #    - 推定残り時間の計算
          
        
      
        

          

            

            
              
            

            #    - メモリ使用量の監視
          
        
      
        

          

            

            
              
            

            #
          
        
      
        

          

            

            
              
            

            # 2. 🎛️ インタラクティブ機能
          
        
      
        

          

            

            
              
            

            #    - 処理のキャンセル機能
          
        
      
        

          

            

            
              
            

            #    - 一時停止・再開機能
          
        
      
        

          

            

            
              
            

            #    - 優先度調整機能
          
        
      
        

          

            

            
              
            

            #
          
        
      
        

          

            

            
              
            

            # 3. 📈 視覚化強化
          
        
      
        

          

            

            
              
            

            #    - プログレスバーのアニメーション
          
        
      
        

          

            

            
              
            

            #    - チャート形式での進捗表示
          
        
      
        

          

            

            
              
            

            #    - エラー分析グラフ
          
        
      
        

          

            

            
              
            

            #
          
        
      
        

          

            

            
              
            

            # 4. 🔔 通知機能
          
        
      
        

          

            

            
              
            

            #    - 完了時のブラウザ通知
          
        
      
        

          

            

            
              
            

            #    - Slack / メール通知連携
          
        
      
        

          

            

            
              
            

            #    - モバイル通知対応
          
        
      
        

          

            

            
              
            

            # ============================================
          
        
      
    
  

    

      
        

          

            

            
              
            

            # frozen_string_literal: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

            module AdminControllers
          
        
      
        

          

            

            
              
            

              # 監査ログ管理コントローラー
          
        
      
        

          

            

            
              
            

              # ============================================
          
        
      
        

          

            

            
              
            

              # Phase 5-2: セキュリティ強化
          
        
      
        

          

            

            
              
            

              # 監査ログの閲覧・検索・エクスポート機能
          
        
      
        

          

            

            
              
            

              # CLAUDE.md準拠: GDPR/PCI DSS対応
          
        
      
        

          

            

            
              
            

              # ============================================
          
        
      
        

          

            

            
              
            

              class AuditLogsController < BaseController
          
        
      
        

          

            

            
              
            

                include AuditLogViewer
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                # CLAUDE.md準拠: セキュリティ機能最適化
          
        
      
        

          

            

            
              
            

                # メタ認知: 監査ログは読み取り専用（コンプライアンス要件）のため編集・削除操作なし
          
        
      
        

          

            

            
              
            

                # 横展開: 他の監査ログ系コントローラーでも同様の考慮が必要
          
        
      
        

          

            

            
              
            

                skip_around_action :audit_sensitive_data_access
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                # CLAUDE.md準拠: 管理者用ページネーション設定
          
        
      
        

          

            

            
              
            

                # メタ認知: 監査ログは管理者向け機能のため、標準的なページサイズを固定
          
        
      
        

          

            

            
              
            

                # 横展開: InventoryLogsControllerと同一パターンで一貫性確保
          
        
      
        

          

            

            
              
            

                PER_PAGE = 20
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                before_action :authorize_audit_log_access!
          
        
      
        

          

            

            
              
            

                before_action :set_audit_log, only: [ :show ]
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                # ============================================
          
        
      
        

          

            

            
              
            

                # アクション
          
        
      
        

          

            

            
              
            

                # ============================================
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                # 監査ログ一覧
          
        
      
        

          

            

            
              
            

                def index
          
        
      
        

          

            

            
              
            

                  @audit_logs = filter_audit_logs
          
        
      
        

          

            

            
              
            

                               .page(params[:page])
          
        
      
        

          

            

            
              
            

                               .per(PER_PAGE)
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                  # 統計情報
          
        
      
        

          

            

            
              
            

                  @stats = audit_log_stats(@audit_logs.except(:limit, :offset))
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                  # 異常検知
          
        
      
        

          

            

            
              
            

                  @anomalies = detect_anomalies(nil, 1.hour)
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                  respond_to do |format|
          
        
      
        

          

            

            
              
            

                    format.html
          
        
      
        

          

            

            
              
            

                    format.json { render json: @audit_logs }
          
        
      
        

          

            

            
              
            

                    format.csv do
          
        
      
        

          

            

            
              
            

                      send_data export_audit_logs(@audit_logs.except(:limit, :offset), :csv),
          
        
      
        

          

            

            
              
            

                                filename: "audit_logs_#{Date.current}.csv",
          
        
      
        

          

            

            
              
            

                                type: "text/csv"
          
        
      
        

          

            

            
              
            

                    end
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                # 監査ログ詳細
          
        
      
        

          

            

            
              
            

                def show
          
        
      
        

          

            

            
              
            

                  # 関連する監査ログ
          
        
      
        

          

            

            
              
            

                  if @audit_log.auditable
          
        
      
        

          

            

            
              
            

                    @related_logs = AuditLog.where(
          
        
      
        

          

            

            
              
            

                      auditable_type: @audit_log.auditable_type,
          
        
      
        

          

            

            
              
            

                      auditable_id: @audit_log.auditable_id
          
        
      
        

          

            

            
              
            

                    ).where.not(id: @audit_log.id)
          
        
      
        

          

            

            
              
            

                     .recent
          
        
      
        

          

            

            
              
            

                     .limit(10)
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                  # この操作自体も監査ログに記録
          
        
      
        

          

            

            
              
            

                  @audit_log.audit_view(current_admin, {
          
        
      
        

          

            

            
              
            

                    viewer_role: current_admin.role,
          
        
      
        

          

            

            
              
            

                    access_reason: params[:reason]
          
        
      
        

          

            

            
              
            

                  })
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                # セキュリティイベント
          
        
      
        

          

            

            
              
            

                def security_events
          
        
      
        

          

            

            
              
            

                  @security_events = AuditLog.security_events
          
        
      
        

          

            

            
              
            

                                            .includes(:user)
          
        
      
        

          

            

            
              
            

                                            .recent
          
        
      
        

          

            

            
              
            

                                            .page(params[:page])
          
        
      
        

          

            

            
              
            

                                            .per(PER_PAGE)
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                  # セキュリティ統計
          
        
      
        

          

            

            
              
            

                  @security_stats = {
          
        
      
        

          

            

            
              
            

                    total_events: @security_events.except(:limit, :offset).count,
          
        
      
        

          

            

            
              
            

                    rate_limit_blocks: @security_events.except(:limit, :offset)
          
        
      
        

          

            

            
              
            

                                                     .where("details LIKE ?", "%rate_limit_exceeded%")
          
        
      
        

          

            

            
              
            

                                                     .count,
          
        
      
        

          

            

            
              
            

                    failed_logins: AuditLog.where(action: "failed_login")
          
        
      
        

          

            

            
              
            

                                          .where(created_at: 24.hours.ago..Time.current)
          
        
      
        

          

            

            
              
            

                                          .count,
          
        
      
        

          

            

            
              
            

                    permission_changes: AuditLog.where(action: "permission_change")
          
        
      
        

          

            

            
              
            

                                              .where(created_at: 7.days.ago..Time.current)
          
        
      
        

          

            

            
              
            

                                              .count
          
        
      
        

          

            

            
              
            

                  }
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                  # 高リスクユーザー
          
        
      
        

          

            

            
              
            

                  @high_risk_users = identify_high_risk_users
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                # ユーザー別監査履歴
          
        
      
        

          

            

            
              
            

                def user_activity
          
        
      
        

          

            

            
              
            

                  @user = Admin.find(params[:user_id])
          
        
      
        

          

            

            
              
            

                  @activities = @user.audit_logs
          
        
      
        

          

            

            
              
            

                                    .includes(:auditable)
          
        
      
        

          

            

            
              
            

                                    .recent
          
        
      
        

          

            

            
              
            

                                    .page(params[:page])
          
        
      
        

          

            

            
              
            

                                    .per(PER_PAGE)
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                  # ユーザー行動分析
          
        
      
        

          

            

            
              
            

                  @user_stats = {
          
        
      
        

          

            

            
              
            

                    total_actions: @activities.except(:limit, :offset).count,
          
        
      
        

          

            

            
              
            

                    actions_breakdown: @activities.except(:limit, :offset).group(:action).count,
          
        
      
        

          

            

            
              
            

                    active_hours: @activities.except(:limit, :offset)
          
        
      
        

          

            

            
              
            

                                            .group_by_hour_of_day(:created_at)
          
        
      
        

          

            

            
              
            

                                            .count,
          
        
      
        

          

            

            
              
            

                    accessed_models: @activities.except(:limit, :offset)
          
        
      
        

          

            

            
              
            

                                              .group(:auditable_type)
          
        
      
        

          

            

            
              
            

                                              .count
          
        
      
        

          

            

            
              
            

                  }
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                  # 異常検知
          
        
      
        

          

            

            
              
            

                  @user_anomalies = detect_anomalies(@user.id, 1.hour)
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                # コンプライアンスレポート
          
        
      
        

          

            

            
              
            

                def compliance_report
          
        
      
        

          

            

            
              
            

                  @start_date = params[:start_date] ? Date.parse(params[:start_date]) : 1.month.ago.to_date
          
        
      
        

          

            

            
              
            

                  @end_date = params[:end_date] ? Date.parse(params[:end_date]) : Date.current
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                  @report_data = generate_compliance_report(@start_date, @end_date)
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                  respond_to do |format|
          
        
      
        

          

            

            
              
            

                    format.html
          
        
      
        

          

            

            
              
            

                    format.pdf do
          
        
      
        

          

            

            
              
            

                      # TODO: PDF生成機能の実装
          
        
      
        

          

            

            
              
            

                      render plain: "PDF export not yet implemented", status: :not_implemented
          
        
      
        

          

            

            
              
            

                    end
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                private
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                # ============================================
          
        
      
        

          

            

            
              
            

                # 認可
          
        
      
        

          

            

            
              
            

                # ============================================
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                # 🔒 セキュリティ実装: 監査ログアクセス権限制御
          
        
      
        

          

            

            
              
            

                # CLAUDE.md準拠: 現在のrole enumに基づく適切な権限チェック
          
        
      
        

          

            

            
              
            

                # メタ認知: 監査ログは最高権限（本部管理者）のみアクセス可能とする
          
        
      
        

          

            

            
              
            

                #
          
        
      
        

          

            

            
              
            

                # 権限設計理由:
          
        
      
        

          

            

            
              
            

                #   - headquarters_admin: 全店舗の監査ログアクセス権限
          
        
      
        

          

            

            
              
            

                #   - store_manager: 担当店舗のみ（将来実装予定）
          
        
      
        

          

            

            
              
            

                #   - その他の権限: アクセス不可（セキュリティ要件）
          
        
      
        

          

            

            
              
            

                #
          
        
      
        

          

            

            
              
            

                # TODO: 🟡 Phase 5（将来拡張）- 権限チェックの細分化
          
        
      
        

          

            

            
              
            

                #   - super_admin権限実装時: super_admin? || headquarters_admin? に変更
          
        
      
        

          

            

            
              
            

                #   - 店舗別監査ログアクセス（store_manager用）
          
        
      
        

          

            

            
              
            

                #   - 読み取り専用 vs 編集権限の分離
          
        
      
        

          

            

            
              
            

                #   - 監査ログ自体のアクセス監査（メタ監査）
          
        
      
        

          

            

            
              
            

                def authorize_audit_log_access!
          
        
      
        

          

            

            
              
            

                  unless current_admin.headquarters_admin?
          
        
      
        

          

            

            
              
            

                    redirect_to admin_root_path,
          
        
      
        

          

            

            
              
            

                                alert: "監査ログへのアクセス権限がありません。本部管理者権限が必要です。"
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                # ============================================
          
        
      
        

          

            

            
              
            

                # データ取得
          
        
      
        

          

            

            
              
            

                # ============================================
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                def set_audit_log
          
        
      
        

          

            

            
              
            

                  @audit_log = AuditLog.find(params[:id])
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                # 高リスクユーザーの特定
          
        
      
        

          

            

            
              
            

                def identify_high_risk_users
          
        
      
        

          

            

            
              
            

                  # 24時間以内の活動を分析
          
        
      
        

          

            

            
              
            

                  recent_window = 24.hours.ago
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                  high_risk_users = []
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                  # 失敗ログインが多いユーザー
          
        
      
        

          

            

            
              
            

                  failed_login_users = AuditLog.where(action: "failed_login", created_at: recent_window..Time.current)
          
        
      
        

          

            

            
              
            

                                              .group(:user_id)
          
        
      
        

          

            

            
              
            

                                              .count
          
        
      
        

          

            

            
              
            

                                              .select { |_, count| count > 3 }
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                  failed_login_users.each do |user_id, count|
          
        
      
        

          

            

            
              
            

                    user = Admin.find_by(id: user_id)
          
        
      
        

          

            

            
              
            

                    next unless user
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                    high_risk_users << {
          
        
      
        

          

            

            
              
            

                      user: user,
          
        
      
        

          

            

            
              
            

                      risk_type: "multiple_failed_logins",
          
        
      
        

          

            

            
              
            

                      risk_score: count * 20,
          
        
      
        

          

            

            
              
            

                      details: "#{count}回のログイン失敗"
          
        
      
        

          

            

            
              
            

                    }
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                  # 大量データアクセス
          
        
      
        

          

            

            
              
            

                  mass_access_users = AuditLog.where(action: %w[view export], created_at: recent_window..Time.current)
          
        
      
        

          

            

            
              
            

                                             .group(:user_id)
          
        
      
        

          

            

            
              
            

                                             .count
          
        
      
        

          

            

            
              
            

                                             .select { |_, count| count > 100 }
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                  mass_access_users.each do |user_id, count|
          
        
      
        

          

            

            
              
            

                    user = Admin.find_by(id: user_id)
          
        
      
        

          

            

            
              
            

                    next unless user
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                    existing = high_risk_users.find { |h| h[:user].id == user.id }
          
        
      
        

          

            

            
              
            

                    if existing
          
        
      
        

          

            

            
              
            

                      existing[:risk_score] += count / 10
          
        
      
        

          

            

            
              
            

                      existing[:details] += ", #{count}件の大量アクセス"
          
        
      
        

          

            

            
              
            

                    else
          
        
      
        

          

            

            
              
            

                      high_risk_users << {
          
        
      
        

          

            

            
              
            

                        user: user,
          
        
      
        

          

            

            
              
            

                        risk_type: "mass_data_access",
          
        
      
        

          

            

            
              
            

                        risk_score: count / 10,
          
        
      
        

          

            

            
              
            

                        details: "#{count}件の大量データアクセス"
          
        
      
        

          

            

            
              
            

                      }
          
        
      
        

          

            

            
              
            

                    end
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                  high_risk_users.sort_by { |h| -h[:risk_score] }
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                # コンプライアンスレポート生成
          
        
      
        

          

            

            
              
            

                def generate_compliance_report(start_date, end_date)
          
        
      
        

          

            

            
              
            

                  logs = AuditLog.by_date_range(start_date, end_date)
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                  {
          
        
      
        

          

            

            
              
            

                    period: {
          
        
      
        

          

            

            
              
            

                      start: start_date,
          
        
      
        

          

            

            
              
            

                      end: end_date
          
        
      
        

          

            

            
              
            

                    },
          
        
      
        

          

            

            
              
            

                    summary: {
          
        
      
        

          

            

            
              
            

                      total_events: logs.count,
          
        
      
        

          

            

            
              
            

                      unique_users: logs.distinct.count(:user_id),
          
        
      
        

          

            

            
              
            

                      data_modifications: logs.where(action: %w[create update delete]).count,
          
        
      
        

          

            

            
              
            

                      data_access: logs.where(action: %w[view export]).count,
          
        
      
        

          

            

            
              
            

                      security_events: logs.security_events.count,
          
        
      
        

          

            

            
              
            

                      authentication_events: logs.authentication_events.count
          
        
      
        

          

            

            
              
            

                    },
          
        
      
        

          

            

            
              
            

                    user_activities: logs.group(:user_id).count.map { |user_id, count|
          
        
      
        

          

            

            
              
            

                      {
          
        
      
        

          

            

            
              
            

                        user: Admin.find_by(id: user_id)&.email || "削除済みユーザー",
          
        
      
        

          

            

            
              
            

                        activity_count: count
          
        
      
        

          

            

            
              
            

                      }
          
        
      
        

          

            

            
              
            

                    }.sort_by { |a| -a[:activity_count] },
          
        
      
        

          

            

            
              
            

                    data_access_summary: logs.where(action: %w[view export])
          
        
      
        

          

            

            
              
            

                                            .group(:auditable_type)
          
        
      
        

          

            

            
              
            

                                            .count,
          
        
      
        

          

            

            
              
            

                    security_summary: {
          
        
      
        

          

            

            
              
            

                      failed_logins: logs.where(action: "failed_login").count,
          
        
      
        

          

            

            
              
            

                      permission_changes: logs.where(action: "permission_change").count,
          
        
      
        

          

            

            
              
            

                      password_changes: logs.where(action: "password_change").count
          
        
      
        

          

            

            
              
            

                    },
          
        
      
        

          

            

            
              
            

                    daily_breakdown: logs.group_by_day(:created_at).count
          
        
      
        

          

            

            
              
            

                  }
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

              end
          
        
      
        

          

            

            
              
            

            end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

            # ============================================
          
        
      
        

          

            

            
              
            

            # TODO: Phase 5以降の拡張予定
          
        
      
        

          

            

            
              
            

            # ============================================
          
        
      
        

          

            

            
              
            

            # 1. 🔴 高度な分析機能
          
        
      
        

          

            

            
              
            

            #    - 機械学習による異常検知
          
        
      
        

          

            

            
              
            

            #    - 予測分析
          
        
      
        

          

            

            
              
            

            #    - リスクスコアリング
          
        
      
        

          

            

            
              
            

            #
          
        
      
        

          

            

            
              
            

            # 2. 🟡 外部連携
          
        
      
        

          

            

            
              
            

            #    - SIEM統合
          
        
      
        

          

            

            
              
            

            #    - SOCへの自動通知
          
        
      
        

          

            

            
              
            

            #    - 外部監査システム連携
          
        
      
        

          

            

            
              
            

            #
          
        
      
        

          

            

            
              
            

            # 3. 🟢 レポート機能強化
          
        
      
        

          

            

            
              
            

            #    - カスタムレポート作成
          
        
      
        

          

            

            
              
            

            #    - 定期レポート自動送信
          
        
      
        

          

            

            
              
            

            #    - ダッシュボード統合
          
        
      
    
  

    

      
        

          

            

            
              
            

            # frozen_string_literal: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            module AdminControllers
          
        
      
        

          

            

            
              
            

              # 管理者画面用のベースコントローラ
          
        
      
        

          

            

            
              
            

              # 全ての管理者向けコントローラはこのクラスを継承する
          
        
      
        

          

            
              1
            

            
              
            

              class BaseController < ApplicationController
          
        
      
        

          

            
              1
            

            
              
            

                include ErrorHandlers
          
        
      
        

          

            
              1
            

            
              
            

                include AdminAuthorization  # 🔒 権限チェック機能の統一
          
        
      
        

          

            
              1
            

            
              
            

                include SecurityCompliance  # 🛡️ セキュリティコンプライアンス機能
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                # AdminControllers用ヘルパーのインクルード
          
        
      
        

          

            
              1
            

            
              
            

                helper AdminControllers::ApplicationHelper
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                before_action :authenticate_admin!
          
        
      
        

          

            
              1
            

            
              
            

                layout "admin"
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                # CSRFトークン検証を有効化
          
        
      
        

          

            
              1
            

            
              
            

                protect_from_forgery with: :exception
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                # 全ての管理者画面で共通のセットアップ処理
          
        
      
        

          

            
              1
            

            
              
            

                before_action :set_admin_info
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                # TODO: コントローラの命名規則
          
        
      
        

          

            

            
              
            

                # AdminControllersモジュール名はAdminモデルとの名前衝突を避けるために使用
          
        
      
        

          

            

            
              
            

                # 将来的な新しいモデル/コントローラの追加時にも同様の名前衝突に注意
          
        
      
        

          

            

            
              
            

                # コントローラモジュール名には「Controllers」サフィックスを使用して区別する
          
        
      
        

          

            

            
              
            

                # 例: UserモデルとUserControllersモジュールなど
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                # TODO: エラーハンドリングとルーティングの注意点
          
        
      
        

          

            

            
              
            

                # 1. 認証関連ルート（Devise）はカスタムエラーハンドリングルートより先に定義する
          
        
      
        

          

            

            
              
            

                # 2. ワイルドカードルート（*path）は常に最後に定義する
          
        
      
        

          

            

            
              
            

                # 3. 新規コントローラ追加時はルーティング順序に注意する
          
        
      
        

          

            

            
              
            

                # 詳細は doc/error_handling_guide.md の「ルーティング順序の問題」を参照
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                # ✅ セキュリティ機能強化（Phase 1完了）
          
        
      
        

          

            

            
              
            

                # - PCI DSS準拠の機密データ保護機能統合
          
        
      
        

          

            

            
              
            

                # - GDPR準拠の個人情報保護機能統合
          
        
      
        

          

            

            
              
            

                # - タイミング攻撃対策の自動適用
          
        
      
        

          

            

            
              
            

                # - 包括的な監査ログ記録機能
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                # 機密データアクセス時の監査ログ記録を設定
          
        
      
        

          

            

            
              
            

                # メタ認知: データ変更・詳細表示アクションのみ監査対象
          
        
      
        

          

            

            
              
            

                # 横展開: 一覧表示（index）は統計データのため監査対象外
          
        
      
        

          

            
              1
            

            
              
            

                audit_sensitive_access :show, :edit, :update, :destroy
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                # TODO: 🟡 Phase 3（中）- セキュリティポリシーの細分化
          
        
      
        

          

            

            
              
            

                # 優先度: 中（現在の一律適用は動作中）
          
        
      
        

          

            

            
              
            

                # 実装内容:
          
        
      
        

          

            

            
              
            

                #   - アクション別セキュリティレベル定義
          
        
      
        

          

            

            
              
            

                #   - 機密度に応じた監査粒度の調整
          
        
      
        

          

            

            
              
            

                #   - 表示専用コントローラーの自動判定
          
        
      
        

          

            

            
              
            

                # 理由: セキュリティオーバーヘッドの最適化
          
        
      
        

          

            

            
              
            

                # 期待効果: パフォーマンス向上、監査ログの品質向上
          
        
      
        

          

            

            
              
            

                # 工数見積: 1週間
          
        
      
        

          

            

            
              
            

                # 依存関係: セキュリティポリシー定義書の策定
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                # TODO: 将来的な機能拡張
          
        
      
        

          

            

            
              
            

                # - 管理者権限レベルによるアクセス制御（role-based authorization）
          
        
      
        

          

            

            
              
            

                # - 共通エラーハンドリング機能の実装
          
        
      
        

          

            

            
              
            

                # - 多言語対応の基盤整備
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                private
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                # 現在ログイン中の管理者情報をビューで参照できるよう設定
          
        
      
        

          

            
              1
            

            
              
            

                def set_admin_info
          
        
      
        

          

            
              80
            

            
              
                
                  else: 80
                
              
                
                  then: 0
                
              
            

                  return unless admin_signed_in?
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              80
            

            
              
            

                  @current_admin = current_admin
          
        
      
        

          

            

            
              
            

                  # Currentクラスにadmin情報を設定
          
        
      
        

          

            
              80
            

            
              
            

                  Current.admin = current_admin
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

              end
          
        
      
        

          

            

            
              
            

            end
          
        
      
    
  

    

      
        

          

            

            
              
            

            # frozen_string_literal: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            module AdminControllers
          
        
      
        

          

            

            
              
            

              # 管理者ダッシュボード画面用コントローラ
          
        
      
        

          

            
              1
            

            
              
            

              class DashboardController < BaseController
          
        
      
        

          

            

            
              
            

                # CLAUDE.md準拠: セキュリティ機能最適化
          
        
      
        

          

            

            
              
            

                # メタ認知: ダッシュボードは統計表示のみで機密データ操作はないため監査不要
          
        
      
        

          

            

            
              
            

                # 横展開: 他の表示専用コントローラーでも同様の考慮が必要
          
        
      
        

          

            
              1
            

            
              
            

                skip_around_action :audit_sensitive_data_access
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def index
          
        
      
        

          

            

            
              
            

                  # パフォーマンス最適化: 統計データを効率的に事前計算
          
        
      
        

          

            

            
              
            

                  calculate_dashboard_statistics
          
        
      
        

          

            

            
              
            

                  load_recent_activities
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                private
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def calculate_dashboard_statistics
          
        
      
        

          

            

            
              
            

                  # Counter Cacheを活用したN+1クエリ最適化（CLAUDE.md準拠）
          
        
      
        

          

            

            
              
            

                  @stats = {
          
        
      
        

          

            

            
              
            

                    total_inventories: Inventory.count,
          
        
      
        

          

            

            
              
            

                    low_stock_count: Inventory.low_stock.count,
          
        
      
        

          

            

            
              
            

                    total_inventory_value: calculate_total_inventory_value,
          
        
      
        

          

            

            
              
            

                    today_operations: today_operations_count,
          
        
      
        

          

            

            
              
            

                    active_inventories: Inventory.where(status: "active").count,
          
        
      
        

          

            

            
              
            

                    archived_inventories: Inventory.where(status: "archived").count,
          
        
      
        

          

            

            
              
            

                    weekly_operations: weekly_operations_count,
          
        
      
        

          

            

            
              
            

                    monthly_operations: monthly_operations_count,
          
        
      
        

          

            

            
              
            

                    average_inventory_value: calculate_average_inventory_value,
          
        
      
        

          

            

            
              
            

                    total_batches: calculate_total_batches,
          
        
      
        

          

            

            
              
            

                    expiring_batches: calculate_expiring_batches,
          
        
      
        

          

            

            
              
            

                    expired_batches: calculate_expired_batches
          
        
      
        

          

            

            
              
            

                  }
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def load_recent_activities
          
        
      
        

          

            

            
              
            

                  # includes最適化で関連データを事前ロード
          
        
      
        

          

            

            
              
            

                  @recent_logs = InventoryLog.includes(:inventory)
          
        
      
        

          

            

            
              
            

                                             .order(created_at: :desc)
          
        
      
        

          

            

            
              
            

                                             .limit(5)
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def calculate_total_inventory_value
          
        
      
        

          

            

            
              
            

                  # SQL集約関数でパフォーマンス最適化
          
        
      
        

          

            

            
              
            

                  Inventory.sum("quantity * price")
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def today_operations_count
          
        
      
        

          

            

            
              
            

                  # 日時範囲でのカウント最適化
          
        
      
        

          

            

            
              
            

                  InventoryLog.where(
          
        
      
        

          

            

            
              
            

                    created_at: Date.current.beginning_of_day..Date.current.end_of_day
          
        
      
        

          

            

            
              
            

                  ).count
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def weekly_operations_count
          
        
      
        

          

            

            
              
            

                  # 週間操作数（過去7日間）
          
        
      
        

          

            

            
              
            

                  InventoryLog.where(
          
        
      
        

          

            

            
              
            

                    created_at: 7.days.ago.beginning_of_day..Date.current.end_of_day
          
        
      
        

          

            

            
              
            

                  ).count
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def monthly_operations_count
          
        
      
        

          

            

            
              
            

                  # 月間操作数（過去30日間）
          
        
      
        

          

            

            
              
            

                  InventoryLog.where(
          
        
      
        

          

            

            
              
            

                    created_at: 30.days.ago.beginning_of_day..Date.current.end_of_day
          
        
      
        

          

            

            
              
            

                  ).count
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def calculate_average_inventory_value
          
        
      
        

          

            

            
              
            

                  # 平均在庫価値（SQL集約関数でパフォーマンス最適化）
          
        
      
        

          

            

            
              
            

                  total_count = Inventory.count
          
        
      
        

          

            

            
              
                
                  then: 0
                
              
                
                  else: 0
                
              
            

                  return 0 if total_count.zero?
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                  (calculate_total_inventory_value.to_f / total_count).round
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def calculate_total_batches
          
        
      
        

          

            

            
              
            

                  # 全バッチ数（Counter Cacheを活用）
          
        
      
        

          

            

            
              
            

                  Inventory.sum(:batches_count)
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def calculate_expiring_batches
          
        
      
        

          

            

            
              
            

                  # 期限間近バッチ数（30日以内に期限切れ）
          
        
      
        

          

            

            
              
            

                  Batch.joins(:inventory)
          
        
      
        

          

            

            
              
            

                       .where("expires_on BETWEEN ? AND ?", Date.current, 30.days.from_now)
          
        
      
        

          

            

            
              
            

                       .count
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def calculate_expired_batches
          
        
      
        

          

            

            
              
            

                  # 期限切れバッチ数
          
        
      
        

          

            

            
              
            

                  Batch.joins(:inventory)
          
        
      
        

          

            

            
              
            

                       .where("expires_on < ?", Date.current)
          
        
      
        

          

            

            
              
            

                       .count
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                # TODO: 🟡 Phase 2（中）- 高度な統計機能実装
          
        
      
        

          

            

            
              
            

                # 優先度: 中（基本機能は動作確認済み）
          
        
      
        

          

            

            
              
            

                # 実装内容: 期限切れ商品アラート、売上予測レポート、システム監視
          
        
      
        

          

            

            
              
            

                # 理由: ダッシュボードの情報価値向上
          
        
      
        

          

            

            
              
            

                # 期待効果: 管理者の意思決定支援、予防的在庫管理
          
        
      
        

          

            

            
              
            

                # 工数見積: 1-2週間
          
        
      
        

          

            

            
              
            

                # 依存関係: Order、Expiration等のモデル実装
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                # TODO: 🟢 Phase 3（推奨）- コントローラディレクトリ構造の横展開確認
          
        
      
        

          

            

            
              
            

                # 優先度: 低（現在の構造は正常動作中）
          
        
      
        

          

            

            
              
            

                # 実装内容: 他のAdminControllersでも同様の最適化パターン適用
          
        
      
        

          

            

            
              
            

                # 理由: 一貫したパフォーマンス最適化とコード品質維持
          
        
      
        

          

            

            
              
            

                # 期待効果: システム全体のレスポンス時間向上
          
        
      
        

          

            

            
              
            

                # 工数見積: 各コントローラー半日
          
        
      
        

          

            

            
              
            

                # 依存関係: なし
          
        
      
        

          

            

            
              
            

              end
          
        
      
        

          

            

            
              
            

            end
          
        
      
    
  

    

      
        

          

            

            
              
            

            # frozen_string_literal: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            module AdminControllers
          
        
      
        

          

            

            
              
            

              # 店舗間移動管理用コントローラ
          
        
      
        

          

            

            
              
            

              # Phase 2: Multi-Store Management - Transfer Workflow
          
        
      
        

          

            
              1
            

            
              
            

              class InterStoreTransfersController < BaseController
          
        
      
        

          

            
              1
            

            
              
            

                include DatabaseAgnosticSearch  # 🔧 MySQL/PostgreSQL両対応検索機能
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                before_action :set_transfer, only: [ :show, :edit, :update, :destroy, :approve, :reject, :complete, :cancel ]
          
        
      
        

          

            
              1
            

            
              
            

                before_action :set_stores_and_inventories, only: [ :new, :create, :edit, :update ]
          
        
      
        

          

            
              1
            

            
              
            

                before_action :ensure_transfer_permissions, except: [ :index, :pending, :analytics ]
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def index
          
        
      
        

          

            

            
              
            

                  # 🔍 パフォーマンス最適化: includesでN+1クエリ対策（CLAUDE.md準拠）
          
        
      
        

          

            

            
              
            

                  @transfers = InterStoreTransfer.includes(:source_store, :destination_store, :inventory, :requested_by, :approved_by)
          
        
      
        

          

            

            
              
            

                                                .accessible_to_admin(current_admin)
          
        
      
        

          

            

            
              
            

                                                .recent
          
        
      
        

          

            

            
              
            

                                                .page(params[:page])
          
        
      
        

          

            

            
              
            

                                                .per(20)
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                  # 🔍 検索・フィルタリング機能
          
        
      
        

          

            

            
              
                
                  then: 0
                
              
                
                  else: 0
                
              
            

                  apply_transfer_filters if filter_params_present?
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                  # 📊 統計情報の効率的計算（SQL集約関数使用）
          
        
      
        

          

            

            
              
            

                  @stats = calculate_transfer_overview_stats
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def show
          
        
      
        

          

            

            
              
            

                  # 🔍 移動詳細情報: 関連データ事前ロード
          
        
      
        

          

            

            
              
            

                  @transfer_history = load_transfer_history(@transfer)
          
        
      
        

          

            

            
              
            

                  @related_transfers = load_related_transfers(@transfer)
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                  # 📊 移動統計
          
        
      
        

          

            

            
              
            

                  @transfer_analytics = calculate_transfer_analytics(@transfer)
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def new
          
        
      
        

          

            

            
              
            

                  # 🏪 移動申請作成: パラメータから初期値設定
          
        
      
        

          

            

            
              
            

                  @transfer = InterStoreTransfer.new
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                  # URLパラメータから初期値を設定
          
        
      
        

          

            

            
              
                
                  then: 0
                
              
                
                  else: 0
                
              
            

                  if params[:source_store_id].present?
          
        
      
        

          

            

            
              
            

                    @transfer.source_store_id = params[:source_store_id]
          
        
      
        

          

            

            
              
            

                    @source_store = Store.find(params[:source_store_id])
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
                
                  then: 0
                
              
                
                  else: 0
                
              
            

                  if params[:inventory_id].present?
          
        
      
        

          

            

            
              
            

                    @transfer.inventory_id = params[:inventory_id]
          
        
      
        

          

            

            
              
            

                    @inventory = Inventory.find(params[:inventory_id])
          
        
      
        

          

            

            
              
            

                    load_inventory_availability
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                  @transfer.requested_by = current_admin
          
        
      
        

          

            

            
              
            

                  @transfer.priority = "normal"
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def create
          
        
      
        

          

            

            
              
            

                  @transfer = InterStoreTransfer.new(transfer_params)
          
        
      
        

          

            

            
              
            

                  @transfer.requested_by = current_admin
          
        
      
        

          

            

            
              
            

                  @transfer.requested_at = Time.current
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                  if @transfer.save
          
        
      
        

          

            

            
              
                
                  then: 0
                
              
            

                    # 🔔 成功通知とリダイレクト
          
        
      
        

          

            

            
              
            

                    redirect_to admin_inter_store_transfer_path(@transfer),
          
        
      
        

          

            

            
              
            

                                notice: "移動申請「#{@transfer.transfer_summary}」が正常に作成されました。"
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                    # TODO: 🔴 Phase 2（高）- 移動申請通知システム
          
        
      
        

          

            

            
              
            

                    # 優先度: 高（ワークフロー効率化）
          
        
      
        

          

            

            
              
            

                    # 実装内容: 移動先店舗管理者・本部管理者への即座通知
          
        
      
        

          

            

            
              
            

                    # 期待効果: 迅速な承認プロセス、在庫切れリスク軽減
          
        
      
        

          

            

            
              
            

                    # send_transfer_notification(@transfer, :created)
          
        
      
        

          

            

            
              
                
                  else: 0
                
              
            

                  else
          
        
      
        

          

            

            
              
            

                    set_stores_and_inventories
          
        
      
        

          

            

            
              
            

                    render :new, status: :unprocessable_entity
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def edit
          
        
      
        

          

            

            
              
            

                  authorize_transfer_modification!(@transfer)
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def update
          
        
      
        

          

            

            
              
            

                  authorize_transfer_modification!(@transfer)
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
                
                  then: 0
                
              
            

                  if @transfer.update(transfer_params)
          
        
      
        

          

            

            
              
            

                    redirect_to admin_inter_store_transfer_path(@transfer),
          
        
      
        

          

            

            
              
            

                                notice: "移動申請が正常に更新されました。"
          
        
      
        

          

            

            
              
                
                  else: 0
                
              
            

                  else
          
        
      
        

          

            

            
              
            

                    set_stores_and_inventories
          
        
      
        

          

            

            
              
            

                    render :edit, status: :unprocessable_entity
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def destroy
          
        
      
        

          

            

            
              
            

                  authorize_transfer_cancellation!(@transfer)
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                  transfer_summary = @transfer.transfer_summary
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                  # CLAUDE.md準拠: ステータスベースの削除制限
          
        
      
        

          

            

            
              
            

                  # TODO: Phase 3 - 移動履歴の永続保存
          
        
      
        

          

            

            
              
            

                  #   - 完了済み移動は削除不可（監査証跡）
          
        
      
        

          

            

            
              
            

                  #   - キャンセル済みも履歴として保持
          
        
      
        

          

            

            
              
            

                  #   - 論理削除フラグの追加検討
          
        
      
        

          

            

            
              
            

                  # 横展開: Inventoryでも同様の履歴保持戦略
          
        
      
        

          

            

            
              
                
                  else: 0
                
              
                
                  then: 0
                
              
            

                  unless @transfer.can_be_cancelled?
          
        
      
        

          

            

            
              
            

                    redirect_to admin_inter_store_transfer_path(@transfer),
          
        
      
        

          

            

            
              
            

                                alert: "#{@transfer.status_text}の移動申請は削除できません。"
          
        
      
        

          

            

            
              
            

                    return
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                  begin
          
        
      
        

          

            

            
              
                
                  then: 0
                
              
            

                    if @transfer.destroy
          
        
      
        

          

            

            
              
            

                      redirect_to admin_inter_store_transfers_path,
          
        
      
        

          

            

            
              
            

                                  notice: "移動申請「#{transfer_summary}」が正常に削除されました。"
          
        
      
        

          

            

            
              
                
                  else: 0
                
              
            

                    else
          
        
      
        

          

            

            
              
            

                      handle_destroy_error(transfer_summary)
          
        
      
        

          

            

            
              
            

                    end
          
        
      
        

          

            

            
              
            

                  rescue ActiveRecord::InvalidForeignKey, ActiveRecord::DeleteRestrictionError => e
          
        
      
        

          

            

            
              
            

                    Rails.logger.warn "Transfer deletion restricted: #{e.message}, transfer_id: #{@transfer.id}"
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                    # CLAUDE.md準拠: ユーザーフレンドリーなエラーメッセージ（日本語化）
          
        
      
        

          

            

            
              
            

                    # メタ認知: 移動履歴削除の場合、監査要件と代替案を明示
          
        
      
        

          

            

            
              
            

                    error_message = case e.message
          
        
      
        

          

            

            
              
                
                  when: 0
                
              
            

                    when /audit.*log.*exist/i, /dependent.*audit.*exist/i
          
        
      
        

          

            

            
              
            

                      "この移動記録には監査ログが関連付けられているため削除できません。\n監査上、移動履歴の保護が必要です。\n\n代替案：移動記録を「キャンセル済み」状態に変更してください。"
          
        
      
        

          

            

            
              
                
                  when: 0
                
              
            

                    when /inventory.*log.*exist/i, /dependent.*inventory.*log.*exist/i
          
        
      
        

          

            

            
              
            

                      "この移動記録には在庫変動履歴が関連付けられているため削除できません。\n在庫管理上、履歴データの保護が必要です。"
          
        
      
        

          

            

            
              
                
                  when: 0
                
              
            

                    when /Cannot delete.*dependent.*exist/i
          
        
      
        

          

            

            
              
            

                      "この移動記録には関連する履歴データが存在するため削除できません。\n関連データ：監査ログ、在庫履歴、承認履歴など"
          
        
      
        

          

            

            
              
                
                  else: 0
                
              
            

                    else
          
        
      
        

          

            

            
              
            

                      "関連するデータが存在するため削除できません。"
          
        
      
        

          

            

            
              
            

                    end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                    handle_destroy_error(transfer_summary, error_message)
          
        
      
        

          

            

            
              
            

                  rescue => e
          
        
      
        

          

            

            
              
            

                    Rails.logger.error "Transfer deletion failed: #{e.message}, transfer_id: #{@transfer.id}"
          
        
      
        

          

            

            
              
            

                    handle_destroy_error(transfer_summary, "削除中にエラーが発生しました。")
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                # 🔄 ワークフローアクション
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def approve
          
        
      
        

          

            

            
              
            

                  authorize_transfer_approval!(@transfer)
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
                
                  then: 0
                
              
            

                  if @transfer.approve!(current_admin)
          
        
      
        

          

            

            
              
            

                    redirect_to admin_inter_store_transfer_path(@transfer),
          
        
      
        

          

            

            
              
            

                                notice: "移動申請「#{@transfer.transfer_summary}」を承認しました。"
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                    # TODO: 🔴 Phase 2（高）- 承認通知システム
          
        
      
        

          

            

            
              
            

                    # send_transfer_notification(@transfer, :approved)
          
        
      
        

          

            

            
              
                
                  else: 0
                
              
            

                  else
          
        
      
        

          

            

            
              
            

                    redirect_to admin_inter_store_transfer_path(@transfer),
          
        
      
        

          

            

            
              
            

                                alert: "移動申請の承認に失敗しました。在庫状況を確認してください。"
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def reject
          
        
      
        

          

            

            
              
            

                  authorize_transfer_approval!(@transfer)
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                  rejection_reason = params[:rejection_reason]
          
        
      
        

          

            

            
              
                
                  then: 0
                
              
                
                  else: 0
                
              
            

                  if rejection_reason.blank?
          
        
      
        

          

            

            
              
            

                    redirect_to admin_inter_store_transfer_path(@transfer),
          
        
      
        

          

            

            
              
            

                                alert: "却下理由を入力してください。"
          
        
      
        

          

            

            
              
            

                    return
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
                
                  then: 0
                
              
            

                  if @transfer.reject!(current_admin, rejection_reason)
          
        
      
        

          

            

            
              
            

                    redirect_to admin_inter_store_transfer_path(@transfer),
          
        
      
        

          

            

            
              
            

                                notice: "移動申請「#{@transfer.transfer_summary}」を却下しました。"
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                    # TODO: 🔴 Phase 2（高）- 却下通知システム
          
        
      
        

          

            

            
              
            

                    # send_transfer_notification(@transfer, :rejected)
          
        
      
        

          

            

            
              
                
                  else: 0
                
              
            

                  else
          
        
      
        

          

            

            
              
            

                    redirect_to admin_inter_store_transfer_path(@transfer),
          
        
      
        

          

            

            
              
            

                                alert: "移動申請の却下に失敗しました。"
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def complete
          
        
      
        

          

            

            
              
            

                  authorize_transfer_execution!(@transfer)
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
                
                  then: 0
                
              
            

                  if @transfer.execute_transfer!
          
        
      
        

          

            

            
              
            

                    redirect_to admin_inter_store_transfer_path(@transfer),
          
        
      
        

          

            

            
              
            

                                notice: "移動「#{@transfer.transfer_summary}」が正常に完了しました。"
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                    # TODO: 🔴 Phase 2（高）- 完了通知システム
          
        
      
        

          

            

            
              
            

                    # send_transfer_notification(@transfer, :completed)
          
        
      
        

          

            

            
              
                
                  else: 0
                
              
            

                  else
          
        
      
        

          

            

            
              
            

                    redirect_to admin_inter_store_transfer_path(@transfer),
          
        
      
        

          

            

            
              
            

                                alert: "移動の実行に失敗しました。在庫状況を確認してください。"
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def cancel
          
        
      
        

          

            

            
              
            

                  authorize_transfer_cancellation!(@transfer)
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                  cancellation_reason = params[:cancellation_reason] || "管理者によるキャンセル"
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
                
                  then: 0
                
              
            

                  if @transfer.can_be_cancelled? && @transfer.update(status: :cancelled)
          
        
      
        

          

            

            
              
            

                    redirect_to admin_inter_store_transfer_path(@transfer),
          
        
      
        

          

            

            
              
            

                                notice: "移動申請「#{@transfer.transfer_summary}」をキャンセルしました。"
          
        
      
        

          

            

            
              
                
                  else: 0
                
              
            

                  else
          
        
      
        

          

            

            
              
            

                    redirect_to admin_inter_store_transfer_path(@transfer),
          
        
      
        

          

            

            
              
            

                                alert: "移動申請のキャンセルに失敗しました。"
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                # 📊 分析・レポート機能
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def pending
          
        
      
        

          

            

            
              
            

                  # 🔍 承認待ち一覧（管理者権限によるフィルタリング）
          
        
      
        

          

            

            
              
            

                  @pending_transfers = InterStoreTransfer.includes(:source_store, :destination_store, :inventory, :requested_by)
          
        
      
        

          

            

            
              
            

                                                       .accessible_to_admin(current_admin)
          
        
      
        

          

            

            
              
            

                                                       .pending
          
        
      
        

          

            

            
              
            

                                                       .order(created_at: :desc)
          
        
      
        

          

            

            
              
            

                                                       .page(params[:page])
          
        
      
        

          

            

            
              
            

                                                       .per(15)
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                  @pending_stats = {
          
        
      
        

          

            

            
              
            

                    total_pending: @pending_transfers.total_count,
          
        
      
        

          

            

            
              
            

                    urgent_count: @pending_transfers.where(priority: "urgent").count,
          
        
      
        

          

            

            
              
            

                    emergency_count: @pending_transfers.where(priority: "emergency").count,
          
        
      
        

          

            

            
              
            

                    avg_waiting_time: calculate_average_waiting_time(@pending_transfers)
          
        
      
        

          

            

            
              
            

                  }
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def analytics
          
        
      
        

          

            

            
              
            

                  # 📈 移動分析ダッシュボード（本部管理者のみ）
          
        
      
        

          

            

            
              
            

                  # authorize_headquarters_admin! # TODO: 権限チェックメソッドの実装
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                  begin
          
        
      
        

          

            

            
              
            

                    # 期間パラメータの安全な処理
          
        
      
        

          

            

            
              
                
                  then: 0
                
              
                
                  else: 0
                
              
            

                    period_days = params[:period]&.to_i
          
        
      
        

          

            

            
              
                
                  then: 0
                
              
                
                  else: 0
                
              
                
                  then: 0
                
              
            

                    @period = if period_days&.positive? && period_days <= 365
          
        
      
        

          

            

            
              
            

                               period_days.days.ago
          
        
      
        

          

            

            
              
                
                  else: 0
                
              
            

                    else
          
        
      
        

          

            

            
              
            

                               30.days.ago
          
        
      
        

          

            

            
              
            

                    end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                    # 分析データの生成（エラーハンドリング付き）
          
        
      
        

          

            

            
              
            

                    @analytics = InterStoreTransfer.transfer_analytics(@period..) rescue {}
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                    # 📊 店舗別統計（CLAUDE.md準拠: 配列構造で返す）
          
        
      
        

          

            

            
              
            

                    # メタ認知: TypeError防止のため、確実に配列として初期化
          
        
      
        

          

            

            
              
            

                    @store_analytics = calculate_store_transfer_analytics(@period) rescue []
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                    # 📈 期間別トレンド（エラーハンドリング強化済み）
          
        
      
        

          

            

            
              
            

                    # TODO: ✅ Phase 1（完了）- status_distributionキー不一致問題解決
          
        
      
        

          

            

            
              
            

                    # 修正内容: ビューで期待されるstatus_distributionキーに統一
          
        
      
        

          

            

            
              
            

                    # セキュリティ強化: ホワイトリスト方式によるSQLインジェクション対策
          
        
      
        

          

            

            
              
            

                    # 横展開確認必要: AdminControllers::StoresController#analytics, DashboardController#analytics
          
        
      
        

          

            

            
              
            

                    @trend_data = calculate_transfer_trends(@period)
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                  rescue => e
          
        
      
        

          

            

            
              
            

                    # CLAUDE.md準拠: エラーハンドリング強化
          
        
      
        

          

            

            
              
            

                    Rails.logger.error "Analytics calculation failed: #{e.message}"
          
        
      
        

          

            

            
              
                
                  then: 0
                
              
                
                  else: 0
                
              
            

                    Rails.logger.error e.backtrace.first(5).join("\n") if e.backtrace
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                    # フォールバック値の設定
          
        
      
        

          

            

            
              
            

                    @period = 30.days.ago
          
        
      
        

          

            

            
              
            

                    @analytics = {}
          
        
      
        

          

            

            
              
            

                    @store_analytics = []
          
        
      
        

          

            

            
              
            

                    @trend_data = {}
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                    flash.now[:alert] = "分析データの取得中にエラーが発生しました。デフォルトデータを表示しています。"
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                private
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def set_transfer
          
        
      
        

          

            

            
              
            

                  @transfer = InterStoreTransfer.find(params[:id])
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def set_stores_and_inventories
          
        
      
        

          

            

            
              
            

                  # 🏪 アクセス可能な店舗のみ表示（権限による制御）
          
        
      
        

          

            

            
              
            

                  @stores = Store.active.accessible_to_admin(current_admin)
          
        
      
        

          

            

            
              
            

                  @inventories = Inventory.active.includes(:store_inventories)
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def transfer_params
          
        
      
        

          

            

            
              
            

                  params.require(:inter_store_transfer).permit(
          
        
      
        

          

            

            
              
            

                    :source_store_id, :destination_store_id, :inventory_id,
          
        
      
        

          

            

            
              
            

                    :quantity, :priority, :reason, :notes, :requested_delivery_date
          
        
      
        

          

            

            
              
            

                  )
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def filter_params_present?
          
        
      
        

          

            

            
              
            

                  params[:search].present? || params[:status].present? ||
          
        
      
        

          

            

            
              
            

                  params[:priority].present? || params[:store_id].present?
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                # ============================================
          
        
      
        

          

            

            
              
            

                # 🔐 認可メソッド（ロールベースアクセス制御）
          
        
      
        

          

            

            
              
            

                # ============================================
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def ensure_transfer_permissions
          
        
      
        

          

            

            
              
                
                  else: 0
                
              
            

                  unless current_admin.can_access_all_stores? ||
          
        
      
        

          

            

            
              
                
                  then: 0
                
              
                
                  else: 0
                
              
            

                         (@transfer&.source_store && current_admin.can_view_store?(@transfer.source_store)) ||
          
        
      
        

          

            

            
              
                
                  then: 0
                
              
                
                  else: 0
                
              
                
                  then: 0
                
              
            

                         (@transfer&.destination_store && current_admin.can_view_store?(@transfer.destination_store))
          
        
      
        

          

            

            
              
            

                    redirect_to admin_root_path,
          
        
      
        

          

            

            
              
            

                                alert: "この移動申請にアクセスする権限がありません。"
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def authorize_transfer_modification!(transfer)
          
        
      
        

          

            

            
              
                
                  else: 0
                
              
            

                  unless current_admin.can_access_all_stores? ||
          
        
      
        

          

            

            
              
            

                         transfer.requested_by == current_admin ||
          
        
      
        

          

            

            
              
                
                  then: 0
                
              
            

                         (transfer.pending? && current_admin.can_manage_store?(transfer.source_store))
          
        
      
        

          

            

            
              
            

                    redirect_to admin_inter_store_transfer_path(transfer),
          
        
      
        

          

            

            
              
            

                                alert: "この移動申請を変更する権限がありません。"
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def authorize_transfer_approval!(transfer)
          
        
      
        

          

            

            
              
                
                  else: 0
                
              
            

                  unless current_admin.can_approve_transfers? &&
          
        
      
        

          

            

            
              
            

                         (current_admin.headquarters_admin? ||
          
        
      
        

          

            

            
              
                
                  then: 0
                
              
            

                          current_admin.can_manage_store?(transfer.destination_store))
          
        
      
        

          

            

            
              
            

                    redirect_to admin_inter_store_transfer_path(transfer),
          
        
      
        

          

            

            
              
            

                                alert: "この移動申請を承認・却下する権限がありません。"
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def authorize_transfer_execution!(transfer)
          
        
      
        

          

            

            
              
                
                  else: 0
                
              
                
                  then: 0
                
              
            

                  unless current_admin.can_approve_transfers? && transfer.completable?
          
        
      
        

          

            

            
              
            

                    redirect_to admin_inter_store_transfer_path(transfer),
          
        
      
        

          

            

            
              
            

                                alert: "この移動を実行する権限がありません。"
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def authorize_transfer_cancellation!(transfer)
          
        
      
        

          

            

            
              
                
                  else: 0
                
              
            

                  unless current_admin.headquarters_admin? ||
          
        
      
        

          

            

            
              
            

                         transfer.requested_by == current_admin ||
          
        
      
        

          

            

            
              
                
                  then: 0
                
              
            

                         current_admin.can_manage_store?(transfer.source_store)
          
        
      
        

          

            

            
              
            

                    redirect_to admin_inter_store_transfer_path(transfer),
          
        
      
        

          

            

            
              
            

                                alert: "この移動申請をキャンセルする権限がありません。"
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def authorize_headquarters_admin!
          
        
      
        

          

            

            
              
                
                  else: 0
                
              
                
                  then: 0
                
              
            

                  unless current_admin.headquarters_admin?
          
        
      
        

          

            

            
              
            

                    redirect_to admin_root_path,
          
        
      
        

          

            

            
              
            

                                alert: "本部管理者のみアクセス可能です。"
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                # ============================================
          
        
      
        

          

            

            
              
            

                # 📊 統計計算メソッド（パフォーマンス最適化）
          
        
      
        

          

            

            
              
            

                # ============================================
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def calculate_transfer_overview_stats
          
        
      
        

          

            

            
              
            

                  accessible_transfers = InterStoreTransfer.accessible_to_admin(current_admin)
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                  {
          
        
      
        

          

            

            
              
            

                    total_transfers: accessible_transfers.count,
          
        
      
        

          

            

            
              
            

                    pending_count: accessible_transfers.pending.count,
          
        
      
        

          

            

            
              
            

                    approved_count: accessible_transfers.approved.count,
          
        
      
        

          

            

            
              
            

                    completed_today: accessible_transfers.completed
          
        
      
        

          

            

            
              
            

                                                          .where(completed_at: Date.current.all_day)
          
        
      
        

          

            

            
              
            

                                                          .count,
          
        
      
        

          

            

            
              
            

                    urgent_pending: accessible_transfers.pending.urgent.count,
          
        
      
        

          

            

            
              
            

                    emergency_pending: accessible_transfers.pending.emergency.count,
          
        
      
        

          

            

            
              
            

                    average_processing_time: calculate_average_processing_time_hours(accessible_transfers.completed.limit(50))
          
        
      
        

          

            

            
              
            

                  }
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def calculate_transfer_analytics(transfer)
          
        
      
        

          

            

            
              
            

                  # 📊 個別移動の分析データ
          
        
      
        

          

            

            
              
            

                  similar_transfers = InterStoreTransfer
          
        
      
        

          

            

            
              
            

                    .where(
          
        
      
        

          

            

            
              
            

                      source_store: transfer.source_store,
          
        
      
        

          

            

            
              
            

                      destination_store: transfer.destination_store,
          
        
      
        

          

            

            
              
            

                      inventory: transfer.inventory
          
        
      
        

          

            

            
              
            

                    )
          
        
      
        

          

            

            
              
            

                    .where.not(id: transfer.id)
          
        
      
        

          

            

            
              
            

                    .completed
          
        
      
        

          

            

            
              
            

                    .limit(10)
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                  {
          
        
      
        

          

            

            
              
            

                    processing_time: transfer.processing_time,
          
        
      
        

          

            

            
              
            

                    similar_transfers_count: similar_transfers.count,
          
        
      
        

          

            

            
              
            

                    average_similar_time: calculate_average_processing_time_hours(similar_transfers),
          
        
      
        

          

            

            
              
            

                    route_efficiency: calculate_route_efficiency(transfer)
          
        
      
        

          

            

            
              
            

                  }
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                # CLAUDE.md準拠: 削除エラー時の共通処理
          
        
      
        

          

            

            
              
            

                # メタ認知: 他のコントローラーとの一貫性維持
          
        
      
        

          

            
              1
            

            
              
            

                def handle_destroy_error(transfer_summary, message = nil)
          
        
      
        

          

            

            
              
            

                  error_message = message || @transfer.errors.full_messages.join("、")
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                  redirect_to admin_inter_store_transfer_path(@transfer),
          
        
      
        

          

            

            
              
            

                              alert: "移動申請「#{transfer_summary}」の削除に失敗しました: #{error_message}"
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def calculate_store_transfer_analytics(period)
          
        
      
        

          

            

            
              
            

                  # 📈 店舗別移動分析（本部管理者用）
          
        
      
        

          

            

            
              
            

                  # CLAUDE.md準拠: N+1クエリ対策とパフォーマンス最適化
          
        
      
        

          

            

            
              
            

                  # メタ認知: ビューで期待される配列構造に合わせてデータを返す
          
        
      
        

          

            

            
              
            

                  # 横展開: 他の統計表示機能でも同様の構造統一が必要
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                  # パフォーマンス最適化: 店舗ごとに個別クエリではなく、まとめて取得
          
        
      
        

          

            

            
              
            

                  all_outgoing = InterStoreTransfer.where(requested_at: period..)
          
        
      
        

          

            

            
              
            

                                                  .includes(:source_store, :destination_store, :inventory)
          
        
      
        

          

            

            
              
            

                                                  .group_by(&:source_store_id)
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                  all_incoming = InterStoreTransfer.where(requested_at: period..)
          
        
      
        

          

            

            
              
            

                                                  .includes(:source_store, :destination_store, :inventory)
          
        
      
        

          

            

            
              
            

                                                  .group_by(&:destination_store_id)
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                  Store.active.includes(:outgoing_transfers, :incoming_transfers)
          
        
      
        

          

            

            
              
            

                       .map do |store|
          
        
      
        

          

            

            
              
            

                    # 事前に取得したデータから該当店舗のものを抽出
          
        
      
        

          

            

            
              
            

                    outgoing_transfers = all_outgoing[store.id] || []
          
        
      
        

          

            

            
              
            

                    incoming_transfers = all_incoming[store.id] || []
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                    outgoing_completed = outgoing_transfers.select { |t| t.status == "completed" }
          
        
      
        

          

            

            
              
            

                    incoming_completed = incoming_transfers.select { |t| t.status == "completed" }
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                    {
          
        
      
        

          

            

            
              
            

                      store: store,
          
        
      
        

          

            

            
              
            

                      stats: {
          
        
      
        

          

            

            
              
            

                        outgoing_count: outgoing_transfers.size,
          
        
      
        

          

            

            
              
            

                        incoming_count: incoming_transfers.size,
          
        
      
        

          

            

            
              
            

                        outgoing_completed: outgoing_completed.size,
          
        
      
        

          

            

            
              
            

                        incoming_completed: incoming_completed.size,
          
        
      
        

          

            

            
              
            

                        net_flow: incoming_completed.size - outgoing_completed.size,
          
        
      
        

          

            

            
              
            

                        approval_rate: calculate_approval_rate_from_array(outgoing_transfers) || 0.0,
          
        
      
        

          

            

            
              
            

                        avg_processing_time: calculate_average_completion_time_from_array(outgoing_completed) || 0.0,
          
        
      
        

          

            

            
              
            

                        most_transferred_items: calculate_most_transferred_items_from_array(outgoing_transfers + incoming_transfers) || [],
          
        
      
        

          

            

            
              
            

                        efficiency_score: calculate_store_efficiency_from_arrays(outgoing_transfers, incoming_transfers) || 0.0
          
        
      
        

          

            

            
              
            

                      }
          
        
      
        

          

            

            
              
            

                    }
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def apply_transfer_filters
          
        
      
        

          

            

            
              
            

                  # 🔍 検索・フィルタリング処理（CLAUDE.md準拠: MySQL/PostgreSQL両対応）
          
        
      
        

          

            

            
              
            

                  # 🔧 修正: ILIKE → DatabaseAgnosticSearch による適切な検索実装
          
        
      
        

          

            

            
              
            

                  # メタ認知: PostgreSQL前提のILIKEをMySQL対応のLIKEに統一
          
        
      
        

          

            

            
              
                
                  then: 0
                
              
                
                  else: 0
                
              
            

                  if params[:search].present?
          
        
      
        

          

            

            
              
            

                    sanitized_search = sanitize_search_term(params[:search])
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                    # 複数テーブル横断検索（在庫名、店舗名）
          
        
      
        

          

            

            
              
            

                    table_column_mappings = {
          
        
      
        

          

            

            
              
            

                      inventory: [ "name" ],
          
        
      
        

          

            

            
              
            

                      source_store: [ "name" ],
          
        
      
        

          

            

            
              
            

                      destination_store: [ "name" ]
          
        
      
        

          

            

            
              
            

                    }
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                    @transfers = search_across_joined_tables(@transfers, table_column_mappings, sanitized_search)
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
                
                  then: 0
                
              
                
                  else: 0
                
              
            

                  @transfers = @transfers.where(status: params[:status]) if params[:status].present?
          
        
      
        

          

            

            
              
                
                  then: 0
                
              
                
                  else: 0
                
              
            

                  @transfers = @transfers.where(priority: params[:priority]) if params[:priority].present?
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
                
                  then: 0
                
              
                
                  else: 0
                
              
            

                  if params[:store_id].present?
          
        
      
        

          

            

            
              
            

                    store_id = params[:store_id]
          
        
      
        

          

            

            
              
            

                    @transfers = @transfers.where(
          
        
      
        

          

            

            
              
            

                      "source_store_id = ? OR destination_store_id = ?",
          
        
      
        

          

            

            
              
            

                      store_id, store_id
          
        
      
        

          

            

            
              
            

                    )
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def load_transfer_history(transfer)
          
        
      
        

          

            

            
              
            

                  # 📋 移動履歴の詳細ロード
          
        
      
        

          

            

            
              
            

                  # TODO: 🟡 Phase 3（中）- 移動履歴の詳細追跡機能
          
        
      
        

          

            

            
              
            

                  # 優先度: 中（監査・分析機能強化）
          
        
      
        

          

            

            
              
            

                  # 実装内容: ステータス変更履歴、承認者コメント、タイムスタンプ
          
        
      
        

          

            

            
              
            

                  # 期待効果: 完全な監査証跡、プロセス改善の根拠データ
          
        
      
        

          

            

            
              
            

                  []
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def load_related_transfers(transfer)
          
        
      
        

          

            

            
              
            

                  # 🔗 関連移動の表示
          
        
      
        

          

            

            
              
            

                  InterStoreTransfer
          
        
      
        

          

            

            
              
            

                    .where(
          
        
      
        

          

            

            
              
            

                      "(source_store_id = ? AND destination_store_id = ?) OR (inventory_id = ?)",
          
        
      
        

          

            

            
              
            

                      transfer.source_store_id, transfer.destination_store_id, transfer.inventory_id
          
        
      
        

          

            

            
              
            

                    )
          
        
      
        

          

            

            
              
            

                    .where.not(id: transfer.id)
          
        
      
        

          

            

            
              
            

                    .includes(:source_store, :destination_store, :inventory)
          
        
      
        

          

            

            
              
            

                    .recent
          
        
      
        

          

            

            
              
            

                    .limit(5)
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def load_inventory_availability
          
        
      
        

          

            

            
              
                
                  else: 0
                
              
                
                  then: 0
                
              
            

                  return unless @source_store && @inventory
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                  @availability = @source_store.store_inventories
          
        
      
        

          

            

            
              
            

                                              .find_by(inventory: @inventory)
          
        
      
        

          

            

            
              
                
                  then: 0
                
              
                
                  else: 0
                
              
            

                  @suggested_quantity = calculate_suggested_quantity(@availability) if @availability
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def calculate_suggested_quantity(store_inventory)
          
        
      
        

          

            

            
              
            

                  # 💡 推奨移動数量の計算
          
        
      
        

          

            

            
              
                
                  else: 0
                
              
                
                  then: 0
                
              
            

                  return 0 unless store_inventory
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                  available = store_inventory.available_quantity
          
        
      
        

          

            

            
              
            

                  safety_level = store_inventory.safety_stock_level
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                  # 安全在庫レベルを超過している分の50%を推奨
          
        
      
        

          

            

            
              
            

                  excess = available - safety_level
          
        
      
        

          

            

            
              
                
                  then: 0
                
              
                
                  else: 0
                
              
            

                  excess > 0 ? (excess * 0.5).ceil : 0
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def calculate_average_waiting_time(transfers)
          
        
      
        

          

            

            
              
            

                  # ⏱️ 平均待機時間計算
          
        
      
        

          

            

            
              
            

                  pending_transfers = transfers.where(status: "pending")
          
        
      
        

          

            

            
              
                
                  then: 0
                
              
                
                  else: 0
                
              
            

                  return 0 if pending_transfers.empty?
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                  total_waiting_time = pending_transfers.sum do |transfer|
          
        
      
        

          

            

            
              
            

                    Time.current - transfer.requested_at
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                  (total_waiting_time / pending_transfers.count / 1.hour).round(1)
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def calculate_average_processing_time_hours(completed_transfers)
          
        
      
        

          

            

            
              
            

                  # ⏱️ 平均処理時間計算（時間単位）
          
        
      
        

          

            

            
              
                
                  then: 0
                
              
                
                  else: 0
                
              
            

                  return 0 if completed_transfers.empty?
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                  total_time = completed_transfers.sum(&:processing_time)
          
        
      
        

          

            

            
              
            

                  (total_time / completed_transfers.count / 1.hour).round(1)
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def calculate_period_trend(transfers, period, date_column = :requested_at)
          
        
      
        

          

            

            
              
            

                  # 📊 期間トレンド計算（groupdate gem無しでの代替実装）
          
        
      
        

          

            

            
              
            

                  total_days = (Time.current.to_date - period.to_date).to_i
          
        
      
        

          

            

            
              
                
                  then: 0
                
              
                
                  else: 0
                
              
            

                  return { trend_percentage: 0.0, is_increasing: false } if total_days <= 1
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                  mid_point = period + (Time.current - period) / 2
          
        
      
        

          

            

            
              
            

                  first_half = transfers.where(date_column => period..mid_point).count
          
        
      
        

          

            

            
              
            

                  second_half = transfers.where(date_column => mid_point..Time.current).count
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
                
                  then: 0
                
              
                
                  else: 0
                
              
            

                  trend_percentage = first_half.zero? ? 0.0 : ((second_half - first_half).to_f / first_half * 100).round(1)
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                  {
          
        
      
        

          

            

            
              
            

                    trend_percentage: trend_percentage,
          
        
      
        

          

            

            
              
            

                    is_increasing: second_half > first_half,
          
        
      
        

          

            

            
              
            

                    first_half_count: first_half,
          
        
      
        

          

            

            
              
            

                    second_half_count: second_half
          
        
      
        

          

            

            
              
            

                  }
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def calculate_transfer_trends(period)
          
        
      
        

          

            

            
              
            

                  # 📈 期間別トレンドデータの計算
          
        
      
        

          

            

            
              
            

                  # CLAUDE.md準拠: エラーハンドリング強化とnilガード実装
          
        
      
        

          

            

            
              
            

                  # メタ認知: ビューで期待されるstatus_distributionキー対応
          
        
      
        

          

            

            
              
            

                  # 横展開: 他の統計表示機能でも同様のキー名統一
          
        
      
        

          

            

            
              
            

                  begin
          
        
      
        

          

            

            
              
            

                    transfers = InterStoreTransfer.where(requested_at: period..)
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                    # 日別リクエスト数と完了数の集計
          
        
      
        

          

            

            
              
            

                    daily_requests = {}
          
        
      
        

          

            

            
              
            

                    daily_completions = {}
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                    (period.to_date..Date.current).each do |date|
          
        
      
        

          

            

            
              
            

                      daily_transfers = transfers.where(requested_at: date.beginning_of_day..date.end_of_day)
          
        
      
        

          

            

            
              
            

                      daily_requests[date] = daily_transfers.count
          
        
      
        

          

            

            
              
            

                      daily_completions[date] = daily_transfers.where(status: "completed").count
          
        
      
        

          

            

            
              
            

                    end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                    # 週別集計
          
        
      
        

          

            

            
              
            

                    weekly_stats = []
          
        
      
        

          

            

            
              
            

                    current_date = period.to_date.beginning_of_week
          
        
      
        

          

            

            
              
                
                  body: 0
                
              
            

                    while current_date <= Date.current
          
        
      
        

          

            

            
              
            

                      week_end = current_date.end_of_week
          
        
      
        

          

            

            
              
            

                      week_count = transfers.where(requested_at: current_date..week_end).count
          
        
      
        

          

            

            
              
            

                      weekly_stats << { week: current_date, count: week_count }
          
        
      
        

          

            

            
              
            

                      current_date = current_date + 1.week
          
        
      
        

          

            

            
              
            

                    end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                    # ステータス別推移（ビューで期待されるキー名に統一）
          
        
      
        

          

            

            
              
            

                    # CLAUDE.md準拠: セキュリティ強化 - SQLインジェクション対策
          
        
      
        

          

            

            
              
            

                    status_distribution = {}
          
        
      
        

          

            

            
              
            

                    %w[pending approved rejected completed cancelled].each do |status|
          
        
      
        

          

            

            
              
            

                      # 安全なステータス値のみ許可（ホワイトリスト方式）
          
        
      
        

          

            

            
              
                
                  then: 0
                
              
                
                  else: 0
                
              
            

                      if InterStoreTransfer.statuses.keys.include?(status)
          
        
      
        

          

            

            
              
            

                        status_distribution[status] = transfers.where(status: status).count
          
        
      
        

          

            

            
              
            

                      end
          
        
      
        

          

            

            
              
            

                    end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                    # 優先度別推移
          
        
      
        

          

            

            
              
            

                    priority_distribution = {}
          
        
      
        

          

            

            
              
            

                    %w[normal urgent emergency].each do |priority|
          
        
      
        

          

            

            
              
            

                      # 安全な優先度値のみ許可（ホワイトリスト方式）
          
        
      
        

          

            

            
              
                
                  then: 0
                
              
                
                  else: 0
                
              
            

                      if InterStoreTransfer.priorities.keys.include?(priority)
          
        
      
        

          

            

            
              
            

                        priority_distribution[priority] = transfers.where(priority: priority).count
          
        
      
        

          

            

            
              
            

                      end
          
        
      
        

          

            

            
              
            

                    end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                    {
          
        
      
        

          

            

            
              
            

                      total_requests: transfers.count,
          
        
      
        

          

            

            
              
            

                      total_completions: transfers.completed.count,
          
        
      
        

          

            

            
              
            

                      daily_requests: daily_requests,
          
        
      
        

          

            

            
              
            

                      daily_completions: daily_completions,
          
        
      
        

          

            

            
              
            

                      weekly_stats: weekly_stats,
          
        
      
        

          

            

            
              
            

                      status_distribution: status_distribution, # ビューで期待されるキー名
          
        
      
        

          

            

            
              
            

                      priority_distribution: priority_distribution,
          
        
      
        

          

            

            
              
            

                      total_period_transfers: transfers.count,
          
        
      
        

          

            

            
              
            

                      period_approval_rate: calculate_approval_rate(transfers),
          
        
      
        

          

            

            
              
            

                      avg_completion_time: calculate_average_completion_time(transfers)
          
        
      
        

          

            

            
              
            

                    }
          
        
      
        

          

            

            
              
            

                  rescue => e
          
        
      
        

          

            

            
              
            

                    # エラー時の完全フォールバック
          
        
      
        

          

            

            
              
            

                    Rails.logger.error "Transfer trends calculation failed: #{e.message}"
          
        
      
        

          

            

            
              
            

                    {
          
        
      
        

          

            

            
              
            

                      total_requests: 0,
          
        
      
        

          

            

            
              
            

                      total_completions: 0,
          
        
      
        

          

            

            
              
            

                      daily_requests: {},
          
        
      
        

          

            

            
              
            

                      daily_completions: {},
          
        
      
        

          

            

            
              
            

                      weekly_stats: [],
          
        
      
        

          

            

            
              
            

                      status_distribution: {},
          
        
      
        

          

            

            
              
            

                      priority_distribution: {},
          
        
      
        

          

            

            
              
            

                      total_period_transfers: 0,
          
        
      
        

          

            

            
              
            

                      period_approval_rate: 0.0,
          
        
      
        

          

            

            
              
            

                      avg_completion_time: 0.0
          
        
      
        

          

            

            
              
            

                    }
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                # TODO: 🟡 Phase 3（中）- 店舗効率性スコア計算強化
          
        
      
        

          

            

            
              
            

                # 優先度: 中（分析機能の詳細化）
          
        
      
        

          

            

            
              
            

                # 実装内容: 地理的効率、時間効率、コスト効率を統合したスコア算出
          
        
      
        

          

            

            
              
            

                # 理由: より精密な店舗パフォーマンス評価
          
        
      
        

          

            

            
              
            

                # 期待効果: 店舗運営改善の具体的指標提供
          
        
      
        

          

            

            
              
            

                # 工数見積: 1週間
          
        
      
        

          

            

            
              
            

                # 依存関係: 地理情報API、コスト管理機能
          
        
      
        

          

            
              1
            

            
              
            

                def calculate_store_efficiency(outgoing_transfers, incoming_transfers)
          
        
      
        

          

            

            
              
            

                  # 基本効率性スコア（承認率と完了率の組み合わせ）
          
        
      
        

          

            

            
              
            

                  total_outgoing = outgoing_transfers.count
          
        
      
        

          

            

            
              
            

                  total_incoming = incoming_transfers.count
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
                
                  then: 0
                
              
                
                  else: 0
                
              
            

                  return 0 if total_outgoing == 0 && total_incoming == 0
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
                
                  then: 0
                
              
                
                  else: 0
                
              
            

                  outgoing_success_rate = total_outgoing > 0 ? (outgoing_transfers.where(status: %w[approved completed]).count.to_f / total_outgoing) : 1.0
          
        
      
        

          

            

            
              
                
                  then: 0
                
              
                
                  else: 0
                
              
            

                  incoming_success_rate = total_incoming > 0 ? (incoming_transfers.where(status: %w[approved completed]).count.to_f / total_incoming) : 1.0
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                  # 効率性スコア（0-100）
          
        
      
        

          

            

            
              
            

                  ((outgoing_success_rate + incoming_success_rate) / 2 * 100).round(1)
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                # パフォーマンス最適化: 配列ベースの効率性計算（N+1回避）
          
        
      
        

          

            
              1
            

            
              
            

                def calculate_store_efficiency_from_arrays(outgoing_transfers, incoming_transfers)
          
        
      
        

          

            

            
              
            

                  total_outgoing = outgoing_transfers.size
          
        
      
        

          

            

            
              
            

                  total_incoming = incoming_transfers.size
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
                
                  then: 0
                
              
                
                  else: 0
                
              
            

                  return 0 if total_outgoing == 0 && total_incoming == 0
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                  outgoing_success = outgoing_transfers.count { |t| %w[approved completed].include?(t.status) }
          
        
      
        

          

            

            
              
            

                  incoming_success = incoming_transfers.count { |t| %w[approved completed].include?(t.status) }
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
                
                  then: 0
                
              
                
                  else: 0
                
              
            

                  outgoing_success_rate = total_outgoing > 0 ? (outgoing_success.to_f / total_outgoing) : 1.0
          
        
      
        

          

            

            
              
                
                  then: 0
                
              
                
                  else: 0
                
              
            

                  incoming_success_rate = total_incoming > 0 ? (incoming_success.to_f / total_incoming) : 1.0
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                  ((outgoing_success_rate + incoming_success_rate) / 2 * 100).round(1)
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                # パフォーマンス最適化: 配列ベースの承認率計算
          
        
      
        

          

            
              1
            

            
              
            

                def calculate_approval_rate_from_array(transfers)
          
        
      
        

          

            

            
              
                
                  then: 0
                
              
                
                  else: 0
                
              
            

                  return 0 if transfers.empty?
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                  approved_count = transfers.count { |t| %w[approved completed].include?(t.status) }
          
        
      
        

          

            

            
              
            

                  ((approved_count.to_f / transfers.size) * 100).round(1)
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                # パフォーマンス最適化: 配列ベースの平均完了時間計算
          
        
      
        

          

            
              1
            

            
              
            

                def calculate_average_completion_time_from_array(completed_transfers)
          
        
      
        

          

            

            
              
                
                  then: 0
                
              
                
                  else: 0
                
              
            

                  return 0 if completed_transfers.empty?
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                  total_time = completed_transfers.sum do |transfer|
          
        
      
        

          

            

            
              
                
                  else: 0
                
              
                
                  then: 0
                
              
            

                    next 0 unless transfer.completed_at && transfer.requested_at
          
        
      
        

          

            

            
              
            

                    transfer.completed_at - transfer.requested_at
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                  (total_time / completed_transfers.size / 1.hour).round(1)
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                # パフォーマンス最適化: 配列ベースの最頻移動商品計算
          
        
      
        

          

            
              1
            

            
              
            

                def calculate_most_transferred_items_from_array(transfers)
          
        
      
        

          

            

            
              
                
                  then: 0
                
              
                
                  else: 0
                
              
            

                  return [] if transfers.empty?
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                  inventory_counts = transfers.group_by(&:inventory).transform_values(&:count)
          
        
      
        

          

            

            
              
            

                  inventory_counts.sort_by { |_, count| -count }.first(3).map do |inventory, count|
          
        
      
        

          

            

            
              
            

                    { inventory: inventory, count: count }
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def calculate_most_transferred_items(store, period)
          
        
      
        

          

            

            
              
            

                  # 最も移動された商品トップ3
          
        
      
        

          

            

            
              
            

                  transfers = InterStoreTransfer.where(
          
        
      
        

          

            

            
              
            

                    "(source_store_id = ? OR destination_store_id = ?) AND requested_at >= ?",
          
        
      
        

          

            

            
              
            

                    store.id, store.id, period
          
        
      
        

          

            

            
              
            

                  ).includes(:inventory)
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                  item_counts = transfers.group_by(&:inventory).transform_values(&:count)
          
        
      
        

          

            

            
              
            

                  item_counts.sort_by { |_, count| -count }.first(3).map do |inventory, count|
          
        
      
        

          

            

            
              
            

                    { inventory: inventory, count: count }
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def calculate_approval_rate(transfers)
          
        
      
        

          

            

            
              
            

                  # 承認率の計算
          
        
      
        

          

            

            
              
            

                  total = transfers.count
          
        
      
        

          

            

            
              
                
                  then: 0
                
              
                
                  else: 0
                
              
            

                  return 0 if total.zero?
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                  approved = transfers.where(status: %w[approved completed]).count
          
        
      
        

          

            

            
              
            

                  ((approved.to_f / total) * 100).round(1)
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def calculate_average_completion_time(transfers)
          
        
      
        

          

            

            
              
            

                  # 平均完了時間の計算（時間単位）
          
        
      
        

          

            

            
              
            

                  completed = transfers.where(status: "completed").where.not(completed_at: nil)
          
        
      
        

          

            

            
              
                
                  then: 0
                
              
                
                  else: 0
                
              
            

                  return 0 if completed.empty?
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                  total_time = completed.sum do |transfer|
          
        
      
        

          

            

            
              
            

                    transfer.completed_at - transfer.requested_at
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                  (total_time / completed.count / 1.hour).round(1)
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def calculate_route_efficiency(transfer)
          
        
      
        

          

            

            
              
            

                  # 📊 ルート効率性計算
          
        
      
        

          

            

            
              
            

                  # TODO: 🟡 Phase 3（中）- 地理的効率性分析
          
        
      
        

          

            

            
              
            

                  # 優先度: 中（コスト最適化）
          
        
      
        

          

            

            
              
            

                  # 実装内容: 距離・時間・コストを考慮したルート効率分析
          
        
      
        

          

            

            
              
            

                  # 期待効果: 配送コスト削減、最適ルート提案
          
        
      
        

          

            

            
              
            

                  85 + rand(15) # プレースホルダー: 85-100%の効率性
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                # ============================================
          
        
      
        

          

            

            
              
            

                # TODO: Phase 2以降で実装予定の機能
          
        
      
        

          

            

            
              
            

                # ============================================
          
        
      
        

          

            

            
              
            

                # 1. 🔴 通知システム統合
          
        
      
        

          

            

            
              
            

                #    - メール・Slack・管理画面通知の自動送信
          
        
      
        

          

            

            
              
            

                #    - 承認者エスカレーション機能
          
        
      
        

          

            

            
              
            

                #
          
        
      
        

          

            

            
              
            

                # 2. 🟡 バッチ移動機能
          
        
      
        

          

            

            
              
            

                #    - 複数商品の一括移動申請
          
        
      
        

          

            

            
              
            

                #    - 定期移動スケジュール機能
          
        
      
        

          

            

            
              
            

                #
          
        
      
        

          

            

            
              
            

                # 3. 🟢 高度な分析機能
          
        
      
        

          

            

            
              
            

                #    - 移動パターン分析・予測
          
        
      
        

          

            

            
              
            

                #    - 最適化提案アルゴリズム
          
        
      
        

          

            

            
              
            

              end
          
        
      
        

          

            

            
              
            

            end